simpleTime1516e.cxx and simpleTimeFedAmb1516e.cxx (simpleTimeFedAmb1516e.h) have the RTI calls and federate ambassador calls for the HLA Evolved version of rtisimple.
This page has the code for the following files:
simpleTime1516e.cxx
#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 <iostream>
#include <wchar.h>
#include <sstream>
#include <string>
#include <sstream>
#include <iterator>
#include <RTI/RTI1516.h>
#include <RTI/RTIambassadorFactory.h>
using namespace std;
using namespace rti1516e;
{
bool connected=false;
try
{
connected = true;
}
{
wcout << L"RTI Exception: "
<< ex.
what().c_str() << endl;
return;
}
if (connected)
{
wcout << L"Connected." << endl;
}
else
{
wcout << L"Unable to connect." << endl;
exit(0);
}
}
std::wstring const& fedName,
std::wstring const& fedFile)
{
std::cout << "createFederationExecution "
try
{
}
catch(FederationExecutionAlreadyExists& ex)
{
std::cout << "Could not create Federation Execution: "
<< "FederationExecutionAlreadyExists: "
}
{
std::cout << "RTI Exception: "
<< "Could not create Federation Execution: " << endl;
exit(0);
}
std::cout << "Federation Created." << endl;
}
std::wstring const& federateType, std::wstring const& federationName)
{
bool joined=false;
const int maxTry = 10;
int numTries = 0;
std::cout << "joinFederationExecution "
while (!joined && numTries++ < maxTry)
{
try
{
joined = true;
}
catch(FederationExecutionDoesNotExist)
{
std::cout << "FederationExecutionDoesNotExist, try "
<< numTries << " out of "
<< maxTry << endl;
continue;
}
{
std::cout << "RTI Exception: "
return;
}
}
if (joined)
{
std::cout << "Joined Federation." << endl;
}
else
{
std::cout << "Giving up." << endl;
exit(0);
}
}
{
try
{
rtiAmb->disconnect();
}
{
std::cout << "RTI Exception: "
std::cout << "During resign and destroy." << endl;
}
}
{
try
{
}
{
std::cout << "RTI Exception: "
std::cout << "Could not get object class handle: "
return false;
}
std::wstring attrName;
string currentAttribute("");
for( ; attributeSetIterator != attributeSetEnd; ++attributeSetIterator)
{
currentAttribute = *attributeSetIterator;
try
{
retrievedHandle =
}
{
std::cout << "RTI Exception: "
std::cout << "Could not get attribute handle "
return false;
}
hSet.insert(retrievedHandle);
std::make_pair(
retrievedHandle,
currentAttribute.c_str(),
currentAttribute.length() + 1)));
std::make_pair(
DtToWString(currentAttribute.c_str()), retrievedHandle));
}
int cnt=0;
try
{
cnt=1;
}
{
std::cout << "RTI Exception: "
std::cout << "Could not "
<< (cnt ? "publish" : "subscribe") << endl;
return false;
}
std::string objectName("Talk");
try
{
unsigned int objId = abs(getpid());
std::stringstream pid;
pid << objId;
objectName += pid.str();
int count = 0;
{
}
if (count < 100)
{
}
else
{
std::cout << "Failed waiting for reserve object name "
<< objectName << endl;
return false;
}
}
{
std::cout << "RTI Exception: "
std::cout << "Could not Register Object "
<< objectName
<< " with class "
return false;
}
std::cout << "Registered object "
<< objectName
<< " with class name "
return true;
}
{
try
{
}
{
std::cout << "RTI Exception: "
std::cout << "Could not get interaction class handle: "
return false;
}
string paramName;
for( ; parameterIter != parameterEnd; ++parameterIter )
{
paramName = *parameterIter;
try
{
retrievedHandle =
}
{
std::cout << "RTI Exception: "
std::cout << "Could not get parameter handle "
<< paramName << endl;
return false;
}
retrievedHandle,
paramName.c_str(),
paramName.length() + 1 )));
std::make_pair(
DtToWString(paramName.c_str()), retrievedHandle));
}
int cnt=0;
try
{
cnt=1;
}
{
std::cout << "Could not "
<< (cnt ? "publish" : "subscribe")
<< " to interaction class." << endl;
return false;
}
std::cout << "Subscribed to interaction class: "
<< " with handle: "
<< " and interaction class "
<< " with handle: "
<<
DtToString(detonateInteractionHandle.toString()) << endl;
return true;
}
{
try
{
{
}
delete rtiAmb;
}
{
std::cout << "RTI Exception (during exit): "
}
#ifdef WIN32
WSACleanup();
#endif
exit(0);
}
{
}
{
}
{
{
#ifdef WIN32
#else
#endif
}
}
{
#ifdef WIN32
Sleep(10);
#else
usleep(10 * 1000);
#endif
}
{
{
#ifdef _WIN32
Sleep( 0 );
#elif __solaris__
yield();
#else
sched_yield();
#endif
}
}
{
try
{
std::cout << "Waiting to become Time Regulating " << endl;
{
std::cout << ".";
{
}
}
std::cout << endl;
std::cout << "Waiting to become Time Constrained \n";
{
std::cout << ".";
{
}
{
}
}
cout << std::endl;
}
{
std::cout << " unable to become regulating and constrained\n"
<< " Exiting ...\n";
}
}
{
{
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;
std::cout << " Master waiting for all federates to Join.\n";
{
{
}
}
std::cout << " Master federate has discovered the required number of other federates.\n\n";
ourTag);
{
{
}
}
{
std::cout <<
" We failed to register synch point " <<
DtToString(syncPointLabel) << std::endl
<< " with tag " << synchPointTag << std::endl;
}
std::cout << "Master succesfully registered\n";
}
else
{
std::cout << " Ordinary federate is waiting for synchPoint message\n";
{
{
}
}
std::cout << "sync Point message received\n";
}
try
{
}
{
std::cout << " Synch point achieved failed\n"
<< " Exiting....\n";
}
{
{
}
}
}
int main(
int argc,
char** argv)
{
std::cout << "MAK simpleTime version 1516e" << std::endl;
try
{
if (argc > 1)
{
{
exit(0);
}
}
std::wstring federateType(L"simpletime1516e");
std::cout << "Using "
std::auto_ptr < RTIambassador > rtiAmbAP =
delete rtiAmbFactory;
rtiAmb = rtiAmbAP.release();
joinFedEx(rtiAmb, fedAmb, federateType, federationName);
#ifdef WIN32
WSADATA data;
WSAStartup(MAKEWORD(1,1), &data);
#endif
long count=0;
(*currentTime) += (*oneTimeStep);
{
delete rtiAmb;
return 0;
}
{
}
{
delete rtiAmb;
return 0;
}
{
std::cout << "============================================"
"============================================"
<< endl;
std::cout << " Fedtime (";
std::cout << "), Lookahead (";
std::cout << ") and wallclock time (";
std::cout << ") " << endl;
std::cout << endl;
std::stringstream ss;
ss << "1516e-" << count++;
std::string tag(ss.str());
try{
(*currentTime));
{
string munitionString = "MunitionObjectIdentifier";
ParameterHandleValueMap::iterator munitionData =
(*currentTime));
}
{
string fireString = "FiringObjectIdentifier";
ParameterHandleValueMap::iterator fireData =
(*currentTime));
}
}
catch( InvalidLogicalTime& ex)
{
std::cout << "RTI Invalid Logical Time" << endl;
<< "Could not update object or send interaction"
<< endl;
}
{
std::cout << "RTI Exception "
<< endl
<< " Could not update object or send interaction"
<< endl;
}
int kb(0);
try
{
{
(*currentRTITime) += (*oneTimeStep);
(*currentTime) += (*oneTimeStep);
{
if (kb < 0)
{
break;
}
else if ( kb == 1 )
{
cout << "**********Firing at time " ;
cout << "*************\n";
}
{
}
}
}
}
{
std::cout << "RTI Exception" << endl
<< "Could not advance time" << endl;
}
if ( kb == 0 )
{
}
if (kb < 0)
{
break;
}
else if ( kb == 1 )
{
cout << "**********Firing at time " ;
cout << "*************\n";
}
std::cout << "============================================"
"============================================"
<< endl << endl;
}
delete currentTime;
delete currentRTITime;
delete lookAhead;
delete oneTimeStep;
{
}
if( rtiAmb )
{
delete rtiAmb;
rtiAmb = 0;
}
}
{
std::cout << "RTI Exception (main loop): "
if( rtiAmb )
{
delete rtiAmb;
}
}
#ifdef WIN32
WSACleanup();
#endif
return 0;
}
{
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" )
{
return false;
}
else if ( *cur == "-fedFile" )
{
++cur;
}
else if (*cur == "-m" )
{
{
return false;
}
++cur;
}
else if ( *cur == "-phaseLine" )
{
int phaseLine(0);
if ( !convert<int>(*cur, *next, phaseLine))
{
return false;
}
++cur;
}
else if ( *cur == "-sleepTime" )
{
if ( !convert<int> (*cur, *next,
sleepTime ))
{
return false;
}
++cur;
}
else if ( *cur == "-dedicated" )
{
}
else if ( *cur == "-unManaged" )
{
}
else
{
return false;
}
++cur;
}
return true;
}
simpleTimeFedAmb1516e.cxx
#ifdef WIN32
#pragma warning(disable: 4251)
#pragma warning(disable: 4786)
#pragma warning(disable: 4290)
#endif
#include <iostream>
using namespace std;
otherFederatesReady(
false)
{
}
{
}
NullFederateAmbassador(), myData(data) {}
throw () {}
void
std::wstring const & theObjectInstanceName)
throw (
FederateInternalError)
{
myData.myNameReservationReturned =
myData.myNameReservationSucceeded = true;
}
std::wstring const & theObjectInstanceName)
throw (
FederateInternalError)
{
myData.myNameReservationReturned = true;
myData.myNameReservationSucceeded = false;
}
ObjectInstanceHandle theObject,
std::wstring const & theObjectInstanceName)
throw (
FederateInternalError)
{
++myData.otherFederatesReady;
if ( myData.isMaster )
{
std::cout << " Master federate is aware of "
<< myData.otherFederatesReady + 1
<< " federates, including itself\n";
}
for ( DtAttrNameHandleMap::iterator iter = myData.theAttrNameHandleMap.begin();
iter != myData.theAttrNameHandleMap.end();
++iter )
{
hSet->insert( iter->second );
}
myData.objectInstanceMap[theObject] = theObjectInstanceName;
myData.updateRequestMap.insert( std::make_pair(theObject, hSet) );
delete hSet;
}
ObjectInstanceHandle theObject,
std::wstring const & theObjectInstanceName,
throw (
FederateInternalError)
{
++myData.otherFederatesReady;
if ( myData.isMaster )
{
std::cout << " Master federate is aware of "
<< myData.otherFederatesReady + 1
<< " federates, including itself\n";
}
for ( DtAttrNameHandleMap::iterator iter = myData.theAttrNameHandleMap.begin();
iter != myData.theAttrNameHandleMap.end();
++iter )
{
hSet->insert( iter->second );
}
myData.objectInstanceMap[theObject] = theObjectInstanceName;
myData.updateRequestMap.insert( std::make_pair(theObject, hSet) );
delete hSet;
}
ObjectInstanceHandle theObject,
SupplementalReflectInfo theReflectInfo)
throw (
FederateInternalError)
{
myData.timeManagedObject.addAttrUpdateEvent(tmp);
}
ObjectInstanceHandle theObject,
LogicalTime const & theTime,
SupplementalReflectInfo theReflectInfo)
throw (
FederateInternalError)
{
theAttributeValues,
theUserSuppliedTag,
sentOrder,
theType,
theReflectInfo);
}
ObjectInstanceHandle theObject,
LogicalTime const & theTime,
MessageRetractionHandle theHandle,
SupplementalReflectInfo theReflectInfo)
throw (
FederateInternalError)
{
theAttributeValues,
theUserSuppliedTag,
sentOrder,
theType,
theTime,
theReflectInfo ));
}
SupplementalReceiveInfo theReceiveInfo)
throw (
FederateInternalError)
{
theParameterValues,
theUserSuppliedTag,
sentOrder,
theType,
theReceiveInfo );
myData.timeManagedObject.addInteractionEvent(receivedInteraction);
}
LogicalTime const & theTime,
SupplementalReceiveInfo theReceiveInfo)
throw (
FederateInternalError)
{
theParameterValues,
theUserSuppliedTag,
sentOrder,
theType,
theReceiveInfo);
}
LogicalTime const & theTime,
MessageRetractionHandle theHandle,
SupplementalReceiveInfo theReceiveInfo)
throw (
FederateInternalError)
{
string munitionString("MunitionObjectIdentifier");
string fireString("FiringObjectIdentifier");
if ( myData.theParamNameHandleMap.find(
DtToWString(munitionString.c_str()))
!= myData.theParamNameHandleMap.end() )
{
myData.theParamNameHandleMap.find(
DtToWString(munitionString.c_str()))->second;
ParameterHandleValueMap::const_iterator munitionEntry = theParameterValues.find(munitionHandle);
if ( munitionEntry != theParameterValues.end() )
{
if ( munitionData.
size() == 1 )
{
}
}
}
if ( myData.theParamNameHandleMap.find(
DtToWString(fireString.c_str()))
!= myData.theParamNameHandleMap.end())
{
;
ParameterHandleValueMap::const_iterator fireEntry = theParameterValues.find(fireHandle);
if ( fireEntry != theParameterValues.end() )
{
if ( fireData.
size() == 1 )
{
}
}
}
theInteraction,
theParameterValues,
theUserSuppliedTag,
sentOrder,
theType,
theTime,
receivedOrder,
theReceiveInfo,
interactionType
));
}
ObjectInstanceHandle theObject,
SupplementalRemoveInfo theRemoveInfo)
throw (
FederateInternalError)
{
if ( myData.objectInstanceMap.find(theObject) != myData.objectInstanceMap.end() )
myData.objectInstanceMap.erase(theObject);
myData.timeManagedObject.reset();
}
ObjectInstanceHandle theObject,
LogicalTime const & theTime,
SupplementalRemoveInfo theRemoveInfo)
throw (
FederateInternalError)
{
if ( myData.objectInstanceMap.find(theObject) != myData.objectInstanceMap.end() )
myData.objectInstanceMap.erase(theObject);
}
ObjectInstanceHandle theObject,
LogicalTime const & theTime,
MessageRetractionHandle theHandle,
SupplementalRemoveInfo theRemoveInfo)
throw (
FederateInternalError)
{
if ( myData.objectInstanceMap.find(theObject) != myData.objectInstanceMap.end() )
myData.objectInstanceMap.erase(theObject);
}
ObjectInstanceHandle theObject,
throw (
FederateInternalError)
{
for ( DtAttrNameHandleMap::iterator iter = myData.theAttrNameHandleMap.begin();
iter != myData.theAttrNameHandleMap.end();
++iter )
{
hSet->insert( iter->second );
}
myData.updateRequestMap.insert( std::make_pair(theObject, hSet) );
}
throw (
FederateInternalError)
{
std::cout << " This federate is now able to Regulate time\n";
myData.isRegulating = true;
}
throw (
FederateInternalError)
{
std::cout << " This federate is now time Constrained\n";
myData.isConstrained = true;
}
throw (
FederateInternalError)
{
myData.timeAdvanced = true;
}
throw (FederateInternalError)
{
}
std::wstring const & label)
throw (FederateInternalError)
{
myData.registerSucceeded = true;
}
std::wstring const & label,
throw (FederateInternalError)
{
myData.registerFailed = true;
}
std::wstring const & label,
throw (FederateInternalError)
{
myData.announceSyncReceived = true;
std::cout << "Announce Sync Received for label "
<< reinterpret_cast<const char*>(theUserSuppliedTag.data()) << endl;
}
std::wstring const & label,
throw (
FederateInternalError)
{
myData.federationIsSynchronized = true;
std::cout << " My Federation has been synchronized.\n";
}
simpleTimeKeyboard.cxx
#ifdef WIN32
#include <conio.h>
#else
#include <unistd.h>
#endif
#include <iostream>
{
#ifndef WIN32
tcgetattr(0,&initial_settings);
#endif
}
{
#ifndef WIN32
tcsetattr(0, TCSANOW, &initial_settings);
#endif
}
{
#ifdef WIN32
return _kbhit();
#else
unsigned char ch;
int nread;
nread = read(0,&ch,1);
if (nread == 1)
{
return 1;
}
return 0;
#endif
}
{
char ch;
#ifdef WIN32
ch = _getch();
#else
{
}
else
read(0,&ch,1);
#endif
return ch;
}
{
char key = ' ';
return 0;
while (key !=
'q' && key !=
'Q' &&
kbhit())
if ( key == 'q' || key == 'Q' )
{
return -1;
}
else if ( key == 32 )
{
return 1;
}
else
{
return 0;
}
}
simpleTimeAttribute1516e.cxx
#ifdef WIN32
#pragma warning(disable: 4251)
#pragma warning(disable: 4786)
#pragma warning(disable: 4290)
#endif
const VariableLengthData& userSuppliedTag,
const LogicalTime& fedTime,
const SupplementalReflectInfo theReflectInfo ) :
myTag(static_cast<const char*>( userSuppliedTag.data() )),
myReflectInfo(theReflectInfo)
{
AttributeHandleValueMap::const_iterator iter = ahvps.begin();
AttributeHandleValueMap::const_iterator theEnd = ahvps.end();
for ( ; iter != theEnd; ++iter )
{
myAhvps.insert(std::make_pair(
iter->first,
std::string(static_cast<const char*>(
iter->second.data()))));
}
}
const VariableLengthData& userSuppliedTag,
const SupplementalReflectInfo theReflectInfo ) :
myTag(static_cast<const char*>( userSuppliedTag.data() )),
myReflectInfo(theReflectInfo)
{
AttributeHandleValueMap::const_iterator iter = ahvps.begin();
AttributeHandleValueMap::const_iterator theEnd = ahvps.end();
for ( ; iter != theEnd; ++iter )
{
myAhvps.insert(std::make_pair(
iter->first,
std::string(static_cast<const char*>(
iter->second.data()))));
}
}
{}
{
}
{
}
{
}
{
}
{
}
simpleTimeInteraction1516e.cxx
#ifdef WIN32
#pragma warning(disable: 4251)
#pragma warning(disable: 4786)
#pragma warning(disable: 4290)
#endif
rti1516e::MessageRetractionHandle theRetractionHandle,
const SupplementalReceiveInfo theReceiveInfo,
interaction_type theInteractionType
):
myHandle(theHandle),
myTag(static_cast<const char*>(userSuppliedTag.data())),
myRetractionHandle(theRetractionHandle),
myInteractionType(theInteractionType),
myReceiveInfo(theReceiveInfo)
{
rti1516e::ParameterHandleValueMap::const_iterator iter = phvps.begin();
rti1516e::ParameterHandleValueMap::const_iterator theEnd = phvps.end();
for ( ; iter != theEnd; ++iter )
{
myPhvps.insert( std::make_pair(
iter->first,
std::string(static_cast<const char*>(
iter->second.data())) ) );
}
}
const SupplementalReceiveInfo theReceiveInfo,
interaction_type theInteractionType ) :
myHandle(theHandle),
myTag(static_cast<const char*>(userSuppliedTag.data())),
myRetractionHandle(),
myInteractionType(theInteractionType),
myReceiveInfo(theReceiveInfo)
{
rti1516e::ParameterHandleValueMap::const_iterator iter = phvps.begin();
rti1516e::ParameterHandleValueMap::const_iterator theEnd = phvps.end();
for ( ; iter != theEnd; ++iter )
{
myPhvps.insert( std::make_pair(
iter->first,
std::string(static_cast<const char*>(iter->second.data())) ) );
}
}
const SupplementalReceiveInfo theReceiveInfo,
interaction_type theInteractionType ) :
myHandle(theHandle),
myTag(static_cast<const char*>(userSuppliedTag.data())),
myFedTime(""),
myRetractionHandle(),
myInteractionType(theInteractionType),
myReceiveInfo(theReceiveInfo)
{
rti1516e::ParameterHandleValueMap::const_iterator iter = phvps.begin();
rti1516e::ParameterHandleValueMap::const_iterator theEnd = phvps.end();
for ( ; iter != theEnd; ++iter )
{
myPhvps.insert( std::make_pair(
iter->first,
std::string(static_cast<const char*>(iter->second.data())) ) );
}
}
{ }
{
}
{
}
{
}
{
}
{
}
{
}
{
}
{
}
simpleTimeTimeManagedEntity.cxx
#ifdef WIN32
#pragma warning(disable: 4251)
#pragma warning(disable: 4786)
#pragma warning(disable: 4290)
#endif
#include <assert.h>
#include <iostream>
myPosition(0),
myVelocity(0),
myPhysicalState(Alive),
myState(Initial),
myPhaseLine(150)
{ }
{
{
}
{
}
}
{
}
{
}
{
return retVal;
}
{
return retVal;
}
{
}
{
}
{
}
{
}
{
}
{
}
{
}
{
}
{
{
std::cout << "XXX DEAD XXX\n";
{
}
{
}
}
else
{
{
std::string fedTime = receivedInteraction->
getFedTime();
std::string tag = receivedInteraction->
getTag();
{
std::cout << " received Fire interaction (" << tag << ") at time "
<< fedTime.c_str() << " \n" ;
}
{
std::cout << " received Detonation interaction (" << tag << ") at time "
<< fedTime.c_str() << " \n" ;
}
delete receivedInteraction;
}
{
std::string fedTime = receivedAttrUpdate->
getFedTime();
std::string tag = receivedAttrUpdate->
getTag();
std::cout << " received attribute update (" << tag << ") at time "
<< fedTime.c_str() << " \n" ;
delete receivedAttrUpdate;
}
}
}
{
}
{
}
{
{
{
{
}
break;
break;
break;
}
}
else
{
}
}
timeManagedEntity.cxx
simpleTimeFedAmb1516e.h
#ifndef MyFederateAmbassador_H_
#define MyFederateAmbassador_H_
#ifdef WIN32
#pragma warning(disable: 4251)
#pragma warning(disable: 4786)
#pragma warning(disable: 4290)
#endif
#include <RTI/Enums.h>
#include <RTI/Typedefs.h>
#include <RTI/RTI1516.h>
#include <RTI/NullFederateAmbassador.h>
#include <string>
#include <map>
using namespace rti1516e;
{
public:
public:
bool myNameReservationReturned;
bool myNameReservationSucceeded;
std::map<ObjectClassHandle, std::wstring> objectClassMap;
std::map<ObjectInstanceHandle, std::wstring> objectInstanceMap;
std::map<InteractionClassHandle,std::wstring> interactionClassMap;
std::map<ObjectInstanceHandle, AttributeHandleSet*> updateRequestMap;
std::set<std::string> ourAttrs;
std::set<std::string> ourParms;
bool isMaster;
bool isConstrained;
bool isRegulating;
bool timeAdvanced;
int otherFederatesReady;
bool registerFailed;
bool registerSucceeded;
bool announceSyncReceived;
bool federationIsSynchronized;
};
{
public:
throw () ;
virtual
void
objectInstanceNameReservationSucceeded(std::wstring const &
theObjectInstanceName)
throw (FederateInternalError);
virtual
void
objectInstanceNameReservationFailed(std::wstring const &
theObjectInstanceName)
throw (FederateInternalError);
ObjectInstanceHandle theObject,
std::wstring const & theObjectInstanceName)
throw (FederateInternalError);
ObjectInstanceHandle theObject,
std::wstring const & theObjectInstanceName,
throw (
FederateInternalError);
ObjectInstanceHandle theObject,
SupplementalReflectInfo theReflectInfo)
throw (
FederateInternalError);
ObjectInstanceHandle theObject,
LogicalTime const & theTime,
SupplementalReflectInfo theReflectInfo)
throw (
FederateInternalError);
ObjectInstanceHandle theObject,
LogicalTime const & theTime,
MessageRetractionHandle theHandle,
SupplementalReflectInfo theReflectInfo)
throw (
FederateInternalError);
SupplementalReceiveInfo theReceiveInfo)
throw (
FederateInternalError);
LogicalTime const & theTime,
SupplementalReceiveInfo theReceiveInfo)
throw (
FederateInternalError);
LogicalTime const & theTime,
MessageRetractionHandle theHandle,
SupplementalReceiveInfo theReceiveInfo)
throw (
FederateInternalError);
ObjectInstanceHandle theObject,
SupplementalRemoveInfo theRemoveInfo)
throw (
FederateInternalError);
ObjectInstanceHandle theObject,
LogicalTime const & theTime,
SupplementalRemoveInfo theRemoveInfo)
throw (
FederateInternalError);
ObjectInstanceHandle theObject,
LogicalTime const & theTime,
MessageRetractionHandle theHandle,
SupplementalRemoveInfo theRemoveInfo)
throw (
FederateInternalError);
virtual
void
throw (
FederateInternalError);
virtual
void
throw (
FederateInternalError);
virtual
void
throw (
FederateInternalError);
virtual
void
throw (
FederateInternalError);
virtual
void
throw (FederateInternalError);
virtual
void
throw (FederateInternalError);
virtual
void
throw (FederateInternalError);
virtual
void
throw (FederateInternalError);
std::wstring const & label,
throw (
FederateInternalError);
public:
};
#endif
simpleTimeKeyboard.h
#ifndef MYKBHIT_H_
#define MYKBHIT_H_
#ifndef WIN32
#include <termios.h>
#endif
{
public:
protected:
private:
#ifndef WIN32
#endif
};
#endif
simpleTimeTimeManagedEntity.h
#ifndef _TIMEMANAGEDOBJECTDEFINITION_
#define _TIMEMANAGEDOBJECTDEFINITION_
#ifdef DtIFSPEC1516
#elif defined(DtIFSPEC1516E)
#else
#ifdef DtIFSPEC13DLC
#else
#endif
#endif
#include <queue>
{
public:
private:
private:
};
#endif
simpleTimeStringUtil.h
#ifndef stringUtil_H_
#define stringUtil_H_
#include <string>
#include <sstream>
#include <iomanip>
#include <iostream>
using namespace std;
{
wstring temp;
while (*in_val != '\0')
temp += *in_val++;
return temp;
}
{
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;
}
{
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 >
const string& value,
T& dest )
{
{
std::cout << "Bad Parameter Value\n"
<< "Param: " << param
<< "\tValue: " << value << endl;
return false;
}
return true;
}
#endif
simpleTimeAttribute1516e.h
#ifndef _ATTRIBUTE1516EDEFINITION_
#define _ATTRIBUTE1516EDEFINITION_
#include <map>
#include <string>
#include <RTI/RTI1516.h>
#include <RTI/RTIambassadorFactory.h>
#include <iostream>
using namespace rti1516e;
{
public:
LogicalTime const& fedTime,
const SupplementalReflectInfo theReflectInfo );
const SupplementalReflectInfo theReflectInfo );
const std::map<AttributeHandle, std::string>& getAhvps();
const std::string& getFedTime();
const std::string& getTag();
MessageRetractionHandle getRetractionHandle();
const SupplementalReflectInfo getReflectInfo();
private:
std::map<AttributeHandle, std::string> myAhvps;
std::string myFedTime;
std::string myTag;
MessageRetractionHandle myRetractionHandle;
SupplementalReflectInfo myReflectInfo;
};
#endif // #define _ATTRIBUTE1516DEFINITION_
simpleTimeInteraction1516e.h
#ifndef _INTERACTIONDEFINITION_
#define _INTERACTIONDEFINITION_
#include <map>
#include <string>
#include <RTI/RTI1516.h>
#include <RTI/RTIambassadorFactory.h>
using namespace rti1516e;
{
public:
enum interaction_type{ Unknown, FireType, DetonationType };
rti1516e::MessageRetractionHandle theRetractionHandle,
const SupplementalReceiveInfo theReceiveInfo,
interaction_type theInteractionType = Unknown
);
const SupplementalReceiveInfo theReceiveInfo,
interaction_type theInteractionType = Unknown
);
const SupplementalReceiveInfo theReceiveInfo,
interaction_type theInteractionType = Unknown
);
bool isFireInteraction();
bool isDetonateInteraction();
const std::string& getFedTime();
const std::string& getTag();
const rti1516e::MessageRetractionHandle& getRetractionHandle();
int getTypeOfInteraction();
const SupplementalReceiveInfo getReceiveInfo();
private:
std::map<rti1516e::ParameterHandle, std::string> myPhvps;
std::string myFedTime;
std::string myTag;
rti1516e::MessageRetractionHandle myRetractionHandle;
int myInteractionType;
SupplementalReceiveInfo myReceiveInfo;
};
#endif
stringUtil.h
timeManagedEntity.h
