rtisimple Example Code for HLA 1.3

rtiSimple13.cxx and rtiSimpleFedAmb13.cxx (rtiSimpleFedAmb13.h) have the RTI calls and federate ambassador calls for the HLA 1.3 version of rtisimple.

This page has the code for the following files:

• rtiSimple13.cxx
• rtiSimpleFedAmb13.cxx
• rtiSimpleKeyboard.cxx
• rtiSimpleFedAmb13.h
• rtiSimpleKeyboard.h
• rtiSimpleStringUtil.h

---

rtiSimple13.cxx

/*******************************************************************************
** Copyright (c) 2004 MaK Technologies, Inc.
** 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

#pragma warning(disable: 4786)
#pragma warning(disable: 4290)

#ifdef WIN32
#include <winsock2.h>
#include <process.h>
#else
#include <unistd.h>
#endif

#include <stdio.h>
#include <cstdlib>
#include <cstring>

#include <map>
#include <string>
#include <iostream>
#include <sstream>

#include "RTI.hh"
#include "rtiSimpleFedAmb13.h"
#include "rtiSimpleKeyboard.h"

using namespace std;

// Handles keyboard input without blocking
keyboard input;

// Map between strings and attribute handles
typedef std::map<std::string, RTI::AttributeHandle>  DtAttrNameHandleMap;

// Map between strings and parameter handles
typedef std::map<std::string, RTI::ParameterHandle>  DtParamNameHandleMap;

// Data shared between federate and federate ambassador
DtTalkAmbData theAmbData;

// The federate handle
RTI::FederateHandle theFederateHandle;

// The object class name
std::string theClassName = "BaseEntity";

// The interaction class name
std::string theInterClassName = "WeaponFire";

// The object class handle (to be retrieved from RTI).
RTI::ObjectClassHandle theClassHandle;

// The interaction class handle (to be retrieved from RTI).
RTI::InteractionClassHandle theInterClassHandle;

// The object instance handle (to be retrieved from the RTI).
RTI::ObjectHandle theObjectHandle;

// Map between strings and attribute handles
DtAttrNameHandleMap theAttrNameHandleMap;

// Map between strings and parameter handles
DtParamNameHandleMap theParamNameHandleMap;

// Create the federation execution
void createFedEx(RTI::RTIambassador & rtiAmb,
                 std::string const& fedName,
                 std::string const& fedFile)
{
   cout  << "createFederationExecution "
         << fedName.c_str() << " "
         << fedFile.c_str() << endl;
   try
   {      
      rtiAmb.createFederationExecution(fedName.c_str(), fedFile.c_str());
   }
   catch(RTI::FederationExecutionAlreadyExists& ex)
   {
      cout  << "Could not create Federation Execution: "
            << "FederationExecutionAlreadyExists: "
            <<  ex._name << " "
            << ex._reason << endl;
   }
   catch(RTI::Exception& ex)
   {
      cout  << "Could not create Federation Execution: " << endl
            << "RTI Exception: "
            << ex._name << " "
            << ex._reason << endl;
      exit(0);
   }
   rtiAmb.tick(0.1, 0.2);

   cout << "Federation Created" << endl;
}

// Join the federation execution
void joinFedEx(
   RTI::RTIambassador & rtiAmb, MyFederateAmbassador* fedAmb,
   std::string const& federateType, std::string const& federationName)
{
   bool joined=false;
   const int maxTry  = 10;
   int numTries = 0;
   cout  << "joinFederationExecution "
         << federateType.c_str() << " "
         << federationName.c_str() << endl;

   while (!joined && numTries++ < maxTry)
   {
      try
      {
         theFederateHandle = rtiAmb.joinFederationExecution(federateType.c_str(),
            federationName.c_str(), fedAmb);
         joined = true;
      }
      catch(RTI::FederationExecutionDoesNotExist)
      {
         cout  << "FederationExecutionDoesNotExist, try "
               << numTries << "out of "
               << maxTry << endl;
         continue;
      }
      catch(RTI::Exception& ex)
      {
         cout  << "RTI Exception: "
               << ex._name << " "
               << ex._reason << endl;
         return;
      }
      rtiAmb.tick(0.1, 0.2);
   }
   if (joined)
      cout << "Joined Federation." << endl;
   else
   {
      cout << "Giving up." << endl;
      rtiAmb.destroyFederationExecution(federationName.c_str());
      exit(0);
   }
}

// Resign and destroy the federation execution
void resignAndDestroy( RTI::RTIambassador & rtiAmb,
      std::string const& federationName)
{
   cout << "Resign and Destroy Federation" << endl;
   rtiAmb.resignFederationExecution(RTI::DELETE_OBJECTS);
   rtiAmb.destroyFederationExecution(federationName.c_str());
}

// Save federation

// Request federation save and wait for initiate
// Return save status
bool requestFederationSave(RTI::RTIambassador & rtiAmb, std::string const& label)
{
   bool saveOk = true;
   int count = 0;

   // Turn the signals off
   theAmbData.myReceivedInitiateFederateSave =
      theAmbData.myReceivedFederationSaved =
      theAmbData.myReceivedFederationNotSaved = false;

   cout << "Request federation save with label " << label.c_str() << endl;

   // Request the save and wait for the signal that the save has been initiated
   // or that the federation has not saved (could be that some other federate
   // resigns during save)
   rtiAmb.requestFederationSave(label.c_str());

   while (count++ < 100
      && !theAmbData.myReceivedInitiateFederateSave
      && !theAmbData.myReceivedFederationNotSaved)
   {
      rtiAmb.tick(0.1, 0.2);
   }

   if ( !theAmbData.myReceivedInitiateFederateSave )
   {
      saveOk = false;
      if ( !theAmbData.myReceivedFederationNotSaved )
      {
         cout << "Timed out waiting for initiate federate save\n";
      }
   }
   return saveOk;
}

// Wait for federation saved
// Return save status
bool waitForFederationSaved(RTI::RTIambassador & rtiAmb)
{
   bool saveOk = true;
   int count = 0;

   // Wait until the RTI signals that the entire federation completed the save

   while ( count++ < 100
      && !theAmbData.myReceivedFederationNotSaved
      && !theAmbData.myReceivedFederationSaved )
   {
      rtiAmb.tick(0.1, 0.2);
   }

   if ( !theAmbData.myReceivedFederationSaved )
   {
      saveOk = false;
      if ( !theAmbData.myReceivedFederationNotSaved )
      {
         cout << "Timed out waiting for federation saved\n";
      }
   }
   return saveOk;
}

// Perform save federation
// Return save status
bool saveFederation(RTI::RTIambassador & rtiAmb, std::string const& label, bool performRequest)
{
   bool saveOk = true;
   int count = 0;

   try
   {
      if ( performRequest )
      {
         saveOk = requestFederationSave(rtiAmb, label);
      }

      if ( theAmbData.myReceivedInitiateFederateSave )
      {
         // At this point, the save has been initiated
         // and the federate cannot invoke any other calls except
         // to complete the save (or resign). It signals to the RTI that
         // it will begin saving its own local state

         cout << "Federate save begun\n";
         rtiAmb.federateSaveBegun();

         // Here the federate would save its own state including any context
         // information relating to the RTI
         // (i.e. what classes are published and subscribed
         // object instance handles for registered and discovered objects, etc.

         // Once the federate saves is own data, it signals to the RTI that its
         // save is complete.
         cout << "Federate save complete\n";
         rtiAmb.federateSaveComplete();

         // Wait until the RTI signals that the entire federation completed the save
         saveOk = waitForFederationSaved(rtiAmb);
      }
   }
   catch (RTI::Exception& ex)
   {
      cout  << "RTI Exception: "
         << ex._name << " "
         << ex._reason << endl;
      cout << "Could not  save federation " << label.c_str() << endl;
      saveOk = false;
   }
   catch(exception& stdEx)
   {
      cout << "Standard exception: " << stdEx.what() << endl;
      cout << "Could not  save federation " << label.c_str() << endl;
      saveOk = false;
   }
   catch(...)
   {
      cout << "Unknown exception\n";
      cout << "Could not  save federation " << label.c_str() << endl;
      saveOk = false;
   }

   // Turn the signals off
   theAmbData.myReceivedInitiateFederateSave =
      theAmbData.myReceivedFederationSaved =
      theAmbData.myReceivedFederationNotSaved = false;

   return saveOk;
}

// Restore federation

// Request the restore and wait for the response.
// Return request status
bool requestFederationRestore(RTI::RTIambassador & rtiAmb, std::string const& label)
{
   int count = 0;
   bool restoreOk = true;

   cout << "Request federation restore with label " << label.c_str() << endl;

   // Turn the signals off
   theAmbData.myReceivedRequestFederationRestoreSucceeded =
      theAmbData.myReceivedRequestFederationRestoreFailed =
      theAmbData.myReceivedFederationRestoreBegun =
      theAmbData.myReceivedInitiateFederateRestore =
      theAmbData.myReceivedFederationRestored =
      theAmbData.myReceivedFederationNotRestored = false;

   rtiAmb.requestFederationRestore(label.c_str());
   while (count++ < 100
      && !theAmbData.myReceivedRequestFederationRestoreSucceeded
      && !theAmbData.myReceivedRequestFederationRestoreFailed)
   {
      rtiAmb.tick(0.1, 0.2);
   }

   if ( !theAmbData.myReceivedRequestFederationRestoreSucceeded )
   {
      restoreOk = false;
      if ( !theAmbData.myReceivedRequestFederationRestoreFailed )
      {
         cout << "Timed out waiting for request federation restore succeeded.\n";
      }
   }
   return restoreOk;
}

// Wait for restore begun
// Return begun status
bool waitForRestoreBegun(RTI::RTIambassador & rtiAmb)
{
   bool restoreOk = true;
   // Wait for the restore begun

   cout << "Wait for restore begun\n";
   int count = 0;
   while (count++ < 100
      && !theAmbData.myReceivedFederationRestoreBegun
      && !theAmbData.myReceivedFederationNotRestored)
   {
      rtiAmb.tick(0.1, 0.2);
   }

   if ( !theAmbData.myReceivedFederationRestoreBegun )
   {
      restoreOk = false;
      if (!theAmbData.myReceivedFederationNotRestored)
      {
         cout << "Timed out waiting for federation restore begun.\n";
      }
   }
   return restoreOk;
}

// Wait for initiate restore
// Return initiate status
bool waitForInitiateRestore(RTI::RTIambassador & rtiAmb)
{
   bool restoreOk = true;

   // Wait for the initiate restore

   cout << "Wait for initiate restore\n";

   int count = 0;
   while (count++ < 100
      && !theAmbData.myReceivedInitiateFederateRestore
      && !theAmbData.myReceivedFederationNotRestored)
   {
      rtiAmb.tick(0.1, 0.2);
   }

   if ( theAmbData.myReceivedFederationNotRestored )
   {
      restoreOk = false;
   }
   else if ( !theAmbData.myReceivedInitiateFederateRestore )
   {
      restoreOk = false;
      cout << "Timed out waiting for initiate federate restore.\n";
   }
   else if ( theAmbData.myRestoreFederateHandle != theFederateHandle )
   {
      // In general, a federate must be able to restore any saved state of
      // a federate of the same type. Even if a federate submits
      // a unique federate type string during join, the current federate
      // and object handles may not match those being restored.
      // This simplistic federate implementation cannot handle the case where
      // the federate and object handles are different.
      cout << "Restore initiated with handle " << theAmbData.myRestoreFederateHandle
         << " does not match current handle " << theFederateHandle << endl;
      cout << "Unable to complete restore\n";

      restoreOk = false;

      // Will revert to state before restore was begun
      rtiAmb.federateRestoreNotComplete();

      count = 0;
      while ( count++ < 100
         && !theAmbData.myReceivedFederationNotRestored )
      {
         rtiAmb.tick(0.1, 0.2);
      }

      if ( !theAmbData.myReceivedFederationNotRestored )
      {
         cout << "Timed out waiting for federation not restored.\n";
      }
   }

   return restoreOk;
}

// Wait for federation (not) restored
// Return restore status
bool waitForFederationRestored(RTI::RTIambassador & rtiAmb)
{
   bool restoreOk = true;
   // Wait until the RTI signals that the entire federation completed the restore

   cout << "Wait for federation restored\n";
   int count = 0;
   while ( count++ < 100
      && !theAmbData.myReceivedFederationRestored
      && !theAmbData.myReceivedFederationNotRestored )
   {
      rtiAmb.tick(0.1, 0.2);
   }

   if ( !theAmbData.myReceivedFederationRestored )
   {
      restoreOk = false;
      if ( !theAmbData.myReceivedFederationNotRestored )
      {
         cout << "Timed out waiting for federation restored.\n";
      }
   }
   return restoreOk;
}

// Perform restore federation
// Return restore status
bool restoreFederation(RTI::RTIambassador & rtiAmb, std::string const& label, bool performRequest)
{
   bool restoreOk = true;
   int count = 0;

   try
   {
      if ( performRequest )
      {
         if ( requestFederationRestore(rtiAmb, label) )
         {
            restoreOk = waitForRestoreBegun(rtiAmb);
         }
      }

      if ( theAmbData.myReceivedFederationRestoreBegun )
      {
         // At this point, the restore has begun
         // and the federate cannot invoke any other calls except
         // to complete the restore (or resign). It waits for the
         // initiate restore to begin restoring its local state.

         if ( restoreOk = waitForInitiateRestore(rtiAmb) )
         {
            // Here the federate would restore its own state including any context
            // information relating to the RTI
            // (i.e. what classes are published and subscribed
            // object instance handles for registered and discovered objects, etc.

            // Once the federate restores its own data, it signals to the RTI that its
            // restore is complete.
            wcout << L"Federate restore complete\n";
            rtiAmb.federateRestoreComplete();
            // If the federate was unable to restore its state, it would respond with
            // federateRestoreNotComplete();

            // Now wait for remaining federation to be restored
            restoreOk = waitForFederationRestored(rtiAmb);
         }
      }
   }
   catch (RTI::Exception& ex)
   {
      cout  << "RTI Exception: "
         << ex._name << " "
         << ex._reason << endl;
      cout << "Could not  save federation " << label.c_str() << endl;
      restoreOk = false;
   }
   catch(exception& stdEx)
   {
      cout << "Standard exception: " << stdEx.what() << endl;
      cout << "Could not  save federation " << label.c_str() << endl;
      restoreOk = false;
   }
   catch(...)
   {
      cout << "Unknown exception\n";
      cout << "Could not  save federation " << label.c_str() << endl;
      restoreOk = false;
   }

   // Turn the signals off
   theAmbData.myReceivedRequestFederationRestoreSucceeded =
      theAmbData.myReceivedRequestFederationRestoreFailed =
      theAmbData.myReceivedFederationRestoreBegun =
      theAmbData.myReceivedInitiateFederateRestore =
      theAmbData.myReceivedFederationRestored =
      theAmbData.myReceivedFederationNotRestored = false;

   return restoreOk;
}

// Publish and subscribe the object class attributes.
// Register an object instance of the class.
bool publishSubscribeAndRegisterObject(RTI::RTIambassador & rtiAmb)
{
   // Get the object class handle
   try
   {  
      theClassHandle = rtiAmb.getObjectClassHandle(theClassName.c_str());
      theAmbData.objectClassMap[theClassHandle] = theClassName;
   }
   catch (RTI::Exception& ex)
   {
      cout  << "RTI Exception: "
            << ex._name << " "
            << ex._reason << endl
            << "Could not get object class handle: "
            << theClassName.c_str() << endl;
      return false;
   }

   // Get the attribute handles and construct the name-handle map
   std::string attrName;
   try
   {
      attrName  = "AccelerationVector";
      theAttrNameHandleMap[attrName] = 
            rtiAmb.getAttributeHandle(attrName.c_str(), theClassHandle);
      attrName  = "VelocityVector";
      theAttrNameHandleMap[attrName] = 
            rtiAmb.getAttributeHandle(attrName.c_str(), theClassHandle);
      attrName  = "Orientation";
      theAttrNameHandleMap[attrName] = 
            rtiAmb.getAttributeHandle(attrName.c_str(), theClassHandle);
      attrName  = "DeadReckoningAlgorithm";
      theAttrNameHandleMap[attrName] = 
            rtiAmb.getAttributeHandle(attrName.c_str(), theClassHandle);
      attrName  = "WorldLocation";
      theAttrNameHandleMap[attrName] = 
            rtiAmb.getAttributeHandle(attrName.c_str(), theClassHandle);
   }
   catch (RTI::Exception& ex)
   {
      cout  << "RTI Exception: "
            << ex._name << " "
            << ex._reason << endl
            << "Could not get attribute handle "
            << attrName.c_str() << endl;
      return false;
   }

   // Construct an attribute handle set
   RTI::AttributeHandleSet* hSet = 
      RTI::AttributeHandleSetFactory::create(theAttrNameHandleMap.size());
   for (DtAttrNameHandleMap::iterator iter = theAttrNameHandleMap.begin();
        iter != theAttrNameHandleMap.end();
        iter++)
   {
      hSet->add(iter->second);
   }

    // 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)
   {
      cout  << "RTI Exception: "
            << ex._name << " "
            << ex._reason << endl
            << "Could not "
            << (cnt ? "publish" : "subscribe") << endl;
      delete hSet;
      return false;
   }

   std::string objectName("Talk");

   // Register the object instance
   try
   {
      unsigned int objId = abs(getpid());
      std::stringstream pid;
      pid << objId;
      objectName += pid.str();
      theObjectHandle = rtiAmb.registerObjectInstance(theClassHandle,
            objectName.c_str());
      //theObjectHandle = rtiAmb.registerObjectInstance(theClassHandle);

      // Add name-handle to map
      theAmbData.objectInstanceMap[theObjectHandle] =
         rtiAmb.getObjectInstanceName(theObjectHandle);

      rtiAmb.tick(0.1, 0.2);
   }
   catch (RTI::Exception& ex)
   {
      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;
   }

   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)
{
   // Get the interaction class handle
   try
   {  
      theInterClassHandle = rtiAmb.getInteractionClassHandle(theInterClassName.c_str());
      theAmbData.interactionClassMap[theInterClassHandle] = theInterClassName;
   }
   catch (RTI::Exception& ex)
   {
      cout  << "RTI Exception: "
            << ex._name << " "
            << ex._reason << endl
            << "Could not get interaction class handle: "
            << theInterClassName.c_str() << endl;
      return false;
   }

   // Get the parameter handles and construct the name-handle map
   std::string paramName;
   try
   {
      paramName  = "EventIdentifier";
      theParamNameHandleMap[paramName] = 
            rtiAmb.getParameterHandle(paramName.c_str(), theInterClassHandle);
      paramName  = "FireControlSolutionRange";
      theParamNameHandleMap[paramName] = 
            rtiAmb.getParameterHandle(paramName.c_str(), theInterClassHandle);
      paramName  = "FireMissionIndex";
      theParamNameHandleMap[paramName] = 
            rtiAmb.getParameterHandle(paramName.c_str(), theInterClassHandle);
      paramName  = "FiringLocation";
      theParamNameHandleMap[paramName] = 
            rtiAmb.getParameterHandle(paramName.c_str(), theInterClassHandle);
      paramName  = "FiringObjectIdentifier";
      theParamNameHandleMap[paramName] = 
            rtiAmb.getParameterHandle(paramName.c_str(), theInterClassHandle);
      paramName  = "FuseType";
      theParamNameHandleMap[paramName] = 
            rtiAmb.getParameterHandle(paramName.c_str(), theInterClassHandle);
      paramName  = "InitialVelocityVector";
      theParamNameHandleMap[paramName] = 
            rtiAmb.getParameterHandle(paramName.c_str(), theInterClassHandle);
      paramName  = "MunitionObjectIdentifier";
      theParamNameHandleMap[paramName] = 
            rtiAmb.getParameterHandle(paramName.c_str(), theInterClassHandle);
      paramName  = "MunitionType";
      theParamNameHandleMap[paramName] = 
            rtiAmb.getParameterHandle(paramName.c_str(), theInterClassHandle);
      paramName  = "QuantityFired";
      theParamNameHandleMap[paramName] = 
            rtiAmb.getParameterHandle(paramName.c_str(), theInterClassHandle);
      paramName  = "RateOfFire";
      theParamNameHandleMap[paramName] = 
            rtiAmb.getParameterHandle(paramName.c_str(), theInterClassHandle);
      paramName  = "TargetObjectIdentifier";
      theParamNameHandleMap[paramName] = 
            rtiAmb.getParameterHandle(paramName.c_str(), theInterClassHandle);
      paramName  = "WarheadType";
      theParamNameHandleMap[paramName] = 
            rtiAmb.getParameterHandle(paramName.c_str(), theInterClassHandle);
   }
   catch (RTI::Exception& ex)
   {
      cout  << "RTI Exception: "
            << ex._name << " "
            << ex._reason << endl
            << "Could not get parameter handle "
            << paramName.c_str() << endl;
      return false;
   }

    // Publish and subscribe
   int cnt=0;
   try
   {
   rtiAmb.publishInteractionClass(theInterClassHandle);
   rtiAmb.tick(0.1, 0.2);
   cnt=1;
   rtiAmb.subscribeInteractionClass(theInterClassHandle);
   rtiAmb.tick(0.1, 0.2);
   }
   catch (RTI::Exception& ex)
   {
      cout  << "RTI Exception: "
            << ex._name << " "
            << ex._reason << endl
            << "Could not "
            << (cnt ? "publish" : "subscribe")
            << " to interaction." << endl;
      return false;
   }

   cout  << "Subscribed to interaction class: "
         << theInterClassName.c_str()
         << " with handle: "
         <<  theInterClassHandle << endl;
   return true;
}

int main(int argc, char** argv)
{
   std::cout << "MAK rtiSimple version 1.3" << std::endl;


   try
   {
      // Federate and Federation info
      std::string federationName("MAKsimple");
      std::string federationFile("MAKsimple.fed");
      std::string federateType("rtisimple13");

      if (argc > 1)
      {
         if (strcmp(argv[1], "-h") == 0)
         {
            cout  << "Usage: rtisimple13 [federationName] [federationFile] [federateType]" << endl;
            cout  << "default values: "
                  << "\"" << federationName.c_str() << "\" "
                  << "\"" << federationFile.c_str() <<  "\" "
                  << "\"" << federateType.c_str() <<  "\" " << endl;
            return 0;
         }
         federationName = argv[1];
      }

      if (argc > 2)
      {
         federationFile = argv[2];
      }

      if (argc > 3)
      {
         federateType = argv[3];
      }

      // RTI and Federate Ambassadors
      RTI::RTIambassador rtiAmb;
      MyFederateAmbassador fedAmb(theAmbData);

      RTI::AttributeHandleValuePairSet *attrValues = 0;
      RTI::ParameterHandleValuePairSet *paramValues = 0;

#ifdef WIN32
      WSADATA data;
      WSAStartup(MAKEWORD(1,1), &data);
#endif
      rtiAmb.tick();
      long count=0;
      bool doConnect = true;
      bool connected = false;
      while (1)
      {
         if (doConnect)
         {
            doConnect = false;

            // Create the federation
            createFedEx(rtiAmb, federationName, federationFile);

            // Join the federation
            joinFedEx(rtiAmb, &fedAmb, federateType, federationName);

            // Publish, subscribe and register and object
            if (!publishSubscribeAndRegisterObject(rtiAmb))
            {
               resignAndDestroy(rtiAmb, federationName);
               return 0;
            }

            // Publish and subscribe to the required interaction
            if (!publishAndSubscribeInteraction(rtiAmb))
            {
               resignAndDestroy(rtiAmb, federationName);
               return 0;
            }

            // Construct an attribute handle value pair set with the
            // values containing the attribute names
            attrValues = RTI::AttributeSetFactory::create(theAttrNameHandleMap.size());

            for (DtAttrNameHandleMap::iterator iter = theAttrNameHandleMap.begin();
               iter != theAttrNameHandleMap.end();
               iter++)
            {
               // Attribute values will be just the name of the attribute.
               attrValues->add(iter->second,
                  iter->first.c_str(), iter->first.length()+1);
            }

            // Construct a parameter handle value pair set with the
            // values containing the parameter names
            paramValues = RTI::ParameterSetFactory::create(theParamNameHandleMap.size());

            for (DtParamNameHandleMap::iterator iter2 = theParamNameHandleMap.begin();
               iter2 != theParamNameHandleMap.end();
               iter2++)
            {
               // Parameter values will be just the name of the attribute.
               paramValues->add(iter2->second,
                  iter2->first.c_str(), iter2->first.length()+1);
            }
            connected = true;
         }
         else if (connected)
         {
            std::stringstream ss;
            ss << "1.3-" << count++;
            std::string tag(ss.str());

            // Update the object
            rtiAmb.updateAttributeValues(
               theObjectHandle,
               *attrValues,
               tag.c_str());

            // Send an interaction every few passes
            if ( count % 5 == 0 )  
            {
               cout << "Sending interaction..." << endl;
               rtiAmb.sendInteraction(
                  theInterClassHandle,
                  *paramValues,
                  tag.c_str());
            }

            rtiAmb.tick(0.1, 0.5);

            if ( theAmbData.myReceivedInitiateFederateSave )
            {
               // Perform a save operation
               saveFederation(rtiAmb, theAmbData.mySaveLabel, false);
            }

            if ( theAmbData.myReceivedFederationRestoreBegun )
            {
               // Perform a restore operation
               restoreFederation(rtiAmb, theAmbData.myRestoreLabel, false);
            }
         }

         int key = input.keybrdTick();
         if (key  < 0)
         {
            break;
         }
         else if ('c' == key || 'C' == key )
         {
            doConnect = !connected;
         }
         else if ('d' == key || 'D' == key )
         {
            if (connected)
            {
               try
               {
                  resignAndDestroy(rtiAmb, federationName);
                  if (attrValues)
                  {
                     delete attrValues;
                     attrValues = 0;
                  }
                  if (paramValues)
                  {
                     delete paramValues;
                     paramValues = 0;
                  }
                  connected = false;
               }
               catch(RTI::Exception& ex)
               {
                  cout << "RTI Exception: "
                     << ex._name << " " << ex._reason << endl;
               }
            }
         }
         else if ('s' == key || 'S' == key )
         {
            if (connected)
            {
               // Initiate a save operation
               const std::string saveLabel("rtiSimpleSave");
               if (!saveFederation(rtiAmb, saveLabel, true))
               {
                  // Save failed
                  break;
               }
            }
         }
         else if ('r' == key || 'R' == key )
         {
            if (connected)
            {
               // Initiate a restore operation
               const std::string savedLabel("rtiSimpleSave");
               if (!restoreFederation(rtiAmb, savedLabel, true))
               {
                  // Restore failed
                  break;
               }
            }
         }
         
#ifdef WIN32
         Sleep(2000);
#else
         sleep(2);
#endif
      }

      // Resign and destroy federation
      resignAndDestroy(rtiAmb, federationName);
   }
   catch (RTI::Exception& ex)
   {
      cout  << "RTI Exception (main loop): "
            << ex._name << " "
            << ex._reason << endl;
   }
#ifdef WIN32
   WSACleanup();
#endif

   return 0;

}

rtiSimpleFedAmb13.cxx

/*******************************************************************************
** Copyright (c) 2004 MaK Technologies, Inc.
** All rights reserved.
*******************************************************************************/

#pragma warning(disable: 4786)
#pragma warning(disable: 4290)

#include <stdio.h>
#include <iostream>
#include "rtiSimpleFedAmb13.h"

using namespace std;

void printAttributes(const RTI::AttributeHandleValuePairSet& attributes)
{
   for (unsigned int iloop = 0; iloop < attributes.size(); iloop++)
   {
      RTI::ULong length = attributes.getValueLength(iloop);
      cout  << attributes.getHandle(iloop) << " "
            << attributes.getValuePointer(iloop,length) << endl;
   }
}

void printParameters(const RTI::ParameterHandleValuePairSet& params)
{
   for (unsigned int iloop = 0; iloop < params.size(); iloop++)
   {
      RTI::ULong length = params.getValueLength(iloop);
      cout  << params.getHandle(iloop) << " "
            << params.getValuePointer(iloop,length) << endl;
   }
}

std::string timeToString(RTI::FedTime const& time)
{
   char* buff = new char[time.getPrintableLength()+1];
   ((RTI::FedTime &)time).getPrintableString(buff);
   std::string timeStr(buff);
   delete [] buff;
   return timeStr;
}

MyFederateAmbassador::MyFederateAmbassador(DtTalkAmbData & data) :
   NullFederateAmbassador(), myData(data)
{
}

MyFederateAmbassador::~MyFederateAmbassador()
   throw (RTI::FederateInternalError)
{
   int x = 1;
}

void MyFederateAmbassador::initiateFederateSave(const char* label)
   throw (
      RTI::UnableToPerformSave,
      RTI::FederateInternalError)
{
   cout << "initiateFederateSave: "
      << label << endl;
   myData.myReceivedInitiateFederateSave = true;
   myData.mySaveLabel = label;
}

void MyFederateAmbassador::federationSaved()
   throw (RTI::FederateInternalError)
{
   cout << "federationSaved " << endl;
   myData.myReceivedFederationSaved = true;
}

void MyFederateAmbassador::federationNotSaved()
   throw (RTI::FederateInternalError)
{
   cout << "federationNotSaved: ";
   myData.myReceivedFederationNotSaved = true;
}

void MyFederateAmbassador::requestFederationRestoreSucceeded(const char* label)
   throw (RTI::FederateInternalError)
{
   cout << "requestFederationRestoreSucceeded "
      << label << endl;
   myData.myReceivedRequestFederationRestoreSucceeded = true;
   myData.myRestoreLabel = label;
}

void MyFederateAmbassador::requestFederationRestoreFailed(const char* label,
                                                          const char* reason)
   throw (RTI::FederateInternalError)
{
   cout << "requestFederationRestoreFailed "
      << label << " " << reason << endl;
   myData.myReceivedRequestFederationRestoreFailed = true;
   myData.myRestoreLabel = label;
   myData.myRestoreFailureReason = reason;
}

void MyFederateAmbassador::federationRestoreBegun()
   throw (RTI::FederateInternalError)
{
   cout << "federationRestoreBegun" << endl;
   myData.myReceivedFederationRestoreBegun = true;
}

void MyFederateAmbassador::initiateFederateRestore(
   const char* label,
   RTI::FederateHandle handle)
   throw (
      RTI::SpecifiedSaveLabelDoesNotExist,
      RTI::CouldNotRestore,
      RTI::FederateInternalError)
{
   cout << "initiateFederateRestore " 
      << label << " " << handle << endl;
   myData.myReceivedInitiateFederateRestore = true;
   myData.myRestoreLabel = label;
   myData.myRestoreFederateHandle = handle;
}

void MyFederateAmbassador::federationRestored()
   throw (RTI::FederateInternalError)
{
   cout << "federationRestored" << endl;
   myData.myReceivedFederationRestored = true;
}

void MyFederateAmbassador::federationNotRestored()
throw (RTI::FederateInternalError)
{
   cout << "federationNotRestored" << endl;
   myData.myReceivedFederationNotRestored = true;
}

void MyFederateAmbassador::discoverObjectInstance (
   RTI::ObjectHandle theObject,      
   RTI::ObjectClassHandle theObjectClass, 
   const char* theObjectName)
   throw (
      RTI::CouldNotDiscover,
      RTI::ObjectClassNotKnown,
      RTI::FederateInternalError)
{
   cout  << "discoverObjectInstance: "
         << theObjectName << "("
         << theObject << ") of class "
         << myData.objectClassMap[theObjectClass].c_str() << "( "
         << theObjectClass << ")" << endl;\
   myData.objectInstanceMap[theObject] = theObjectName;
}

void MyFederateAmbassador::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)
{
   cout  << "reflectAttributeValues: "
         << myData.objectInstanceMap[theObject].c_str() << "("
         << theObject << ") "
         << timeToString(theTime).c_str() << " "
         << (theTag ? theTag : "")  << " "
         << "#attributes: " << theAttributes.size() << endl;
   printAttributes(theAttributes);
}

void MyFederateAmbassador::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)
{
   cout  << "reflectAttributeValues: "
         << myData.objectInstanceMap[theObject].c_str() << "("
         << theObject << ") "
         << (theTag ? theTag : "")  << " "
         << "#attributes: " << theAttributes.size() << endl;
   printAttributes(theAttributes);
}

// 4.6
void MyFederateAmbassador::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)
{
   cout  << "receiveInteraction: "
         << myData.interactionClassMap[theInteraction].c_str() << "( "
         << theInteraction << ") " 
         << timeToString(theTime).c_str() << " "
         << (theTag ? theTag : "")  << " "
         << "#parameters: " << theParameters.size() << endl;
   printParameters(theParameters);
}

void MyFederateAmbassador::receiveInteraction (
        RTI::InteractionClassHandle       theInteraction, // supplied C1
  const RTI::ParameterHandleValuePairSet& theParameters,  // supplied C4
  const char                             *theTag)         // supplied C4
throw (
  RTI::InteractionClassNotKnown,
  RTI::InteractionParameterNotKnown,
  RTI::FederateInternalError)
{
   cout  << "receiveInteraction: "
         << myData.interactionClassMap[theInteraction].c_str() << "( "
         << theInteraction << ") " 
         << (theTag ? theTag : "")  << " "
         << "#parameters: " << theParameters.size() << endl;
   printParameters(theParameters);
}

void MyFederateAmbassador::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)
{
   cout  << "removeObjectInstance: "
         << myData.objectInstanceMap[theObject].c_str() << "("
         << theObject << ") "
         << timeToString(theTime).c_str() << " "
         << (theTag ? theTag : "") << endl;
}

void MyFederateAmbassador::removeObjectInstance (
        RTI::ObjectHandle          theObject, // supplied C1
  const char                      *theTag)    // supplied C4
throw (
  RTI::ObjectNotKnown,
  RTI::FederateInternalError)
{
   cout  << "removeObjectInstance: "
         << myData.objectInstanceMap[theObject].c_str() << "("
         << theObject << ") "
         << (theTag ? theTag : "") << endl;
}

rtiSimpleKeyboard.cxx

/*******************************************************************************
* Adapted from "Beginning Linux Programming", from Wrox Press -- www.wrox.com
*******************************************************************************/

#include "rtiSimpleKeyboard.h"

#ifdef WIN32
#include <conio.h>
#else
#include <unistd.h>
#endif

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();
   return (key == 'q' || key == 'Q') ? -1 : key;
}

rtiSimpleFedAmb13.h

/*******************************************************************************
** Copyright (c) 2010 MaK Technologies, Inc.
** All rights reserved.
*******************************************************************************/

#pragma warning(disable: 4786)
#pragma warning(disable: 4290)

#include "NullFederateAmbassador.hh"
#include <map>
#include <string>

class DtTalkAmbData
{
public:
   bool myReceivedInitiateFederateSave;
   bool myReceivedFederationSaved;
   bool myReceivedFederationNotSaved;
   std::string mySaveLabel;

   bool myReceivedRequestFederationRestoreSucceeded;
   bool myReceivedRequestFederationRestoreFailed;
   bool myReceivedFederationRestoreBegun;
   bool myReceivedInitiateFederateRestore;
   bool myReceivedFederationRestored;
   bool myReceivedFederationNotRestored;
   std::string myRestoreLabel;
   RTI::FederateHandle myRestoreFederateHandle;
   std::string myRestoreFailureReason;

   std::map<RTI::ObjectClassHandle, std::string> objectClassMap;
   std::map<RTI::ObjectHandle, std::string> objectInstanceMap;
   std::map<RTI::InteractionClassHandle, std::string> interactionClassMap;
};


class MyFederateAmbassador : public NullFederateAmbassador
{
public:

   MyFederateAmbassador(DtTalkAmbData & data);

   virtual ~MyFederateAmbassador() 
     throw (RTI::FederateInternalError);


   // Federation Management Services //

   virtual void initiateFederateSave (
      const char *label) // supplied C4
   throw (
      RTI::UnableToPerformSave,
      RTI::FederateInternalError);

   virtual void federationSaved ()
   throw (
      RTI::FederateInternalError);

   virtual void federationNotSaved ()
   throw (
      RTI::FederateInternalError);

   virtual void requestFederationRestoreSucceeded (
      const char *label) // supplied C4
   throw (
      RTI::FederateInternalError);

   virtual void requestFederationRestoreFailed (
      const char *label,
      const char *reason) // supplied C4
   throw (
      RTI::FederateInternalError);

   virtual void federationRestoreBegun ()
   throw (
      RTI::FederateInternalError);

   virtual void initiateFederateRestore (
      const char               *label,   // supplied C4
            RTI::FederateHandle handle)  // supplied C1
   throw (
      RTI::SpecifiedSaveLabelDoesNotExist,
      RTI::CouldNotRestore,
      RTI::FederateInternalError);

   virtual void federationRestored ()
   throw (
      RTI::FederateInternalError);

   virtual void federationNotRestored ()
   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);


public:
   DtTalkAmbData & myData;
};

rtiSimpleKeyboard.h

/*******************************************************************************
* Adapted from "Beginning Linux Programming", from Wrox Press -- www.wrox.com
*******************************************************************************/

// 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

rtiSimpleStringUtil.h

/*******************************************************************************
** Copyright (c) 2010 MaK Technologies, Inc.
** All rights reserved.
*******************************************************************************/

#ifndef stringUtil_H_
#define stringUtil_H_

#include <string>
#include <sstream>

// Convert narrow C string to wide string
inline std::wstring DtToWString(const char * in_val)
{
   std::wstring temp;
   while (*in_val != '\0')
   temp += *in_val++;
   return temp;
}

// Convert narrow string to wide string
inline std::string DtToString(const std::wstring &in_val)
{
   std::string temp;
   std::wstring::const_iterator b = in_val.begin();
   const std::wstring::const_iterator e = in_val.end();
   while (b != e)
   {
      temp += static_cast<char>(*b);
      ++b;
   }
   return temp;
}

#endif