//------------------------------------------------------------------------------
// publishAndSubscribe()
//------------------------------------------------------------------------------
bool NetIO::publishAndSubscribe()
{
bool ok = true;
// ----------
// We want the callbacks for attribute level advisories
// ----------
try {
std::cout << "*** Enable Attribute Advisories" << std::endl;
getRTIambassador()->enableAttributeRelevanceAdvisorySwitch();
}
catch (RTI::Exception& e) {
std::cerr << &e << std::endl;
ok = false;
}
// ----------
// Get handles to the class, attributes and parameters
// and publish & Subscribe to class attributes
// ----------
if (ok) ok = publishAndSubscribePlatforms();
if (ok) ok = publishAndSubscribeWeaponFire();
if (ok) ok = publishAndSubscribeMunitionDetonation();
return ok;
}
//------------------------------------------------------------------------------
// updateAttributeValues() -- Send attributes to the RTI
//------------------------------------------------------------------------------
bool NetIO::updateAttributeValues(const RTI::ObjectHandle handle, RTI::AttributeHandleValuePairSet* attrs, const char* theTag)
{
bool ok = true;
if ( attrs->size() > 0) {
try {
if (getRegulating()) {
//DPG getRTIambassador()->queryLookahead(getLookAhead());
getRTIambassador()->updateAttributeValues(handle, *attrs, (getFederationTime()+getLookAhead()), theTag);
}
else {
getRTIambassador()->updateAttributeValues(handle, *attrs, 0);
}
}
catch (RTI::Exception& e) {
std::cerr << &e << std::endl;
ok = false;
}
}
return ok;
}
//------------------------------------------------------------------------------
// sendInteraction() -- Send the interaction via the RTI ambassador
//------------------------------------------------------------------------------
bool NetIO::sendInteraction(const RTI::InteractionClassHandle handle, RTI::ParameterHandleValuePairSet* pParams, const char* theTag)
{
bool ok = true;
try {
getRTIambassador()->sendInteraction( handle, *pParams, theTag);
}
catch (RTI::Exception& e) {
std::cerr << &e << std::endl;
ok = false;
}
return ok;
}
//------------------------------------------------------------------------------
// unPublishAndSubscribe()
//------------------------------------------------------------------------------
bool NetIO::unPublishAndSubscribe()
{
bool ok = true;
try {
// Un-publish and un-subscribe all object classes
for (unsigned int i = 1; i <= MAX_CLASSES; i++) {
RTI::ObjectClassHandle handle = getObjectClassHandle(i);
if (handle > 0) {
if (isObjectClassPublished(i)) {
getRTIambassador()->unpublishObjectClass(handle);
setObjectClassPublished(i,false);
}
if (isObjectClassSubscribed(i)) {
getRTIambassador()->unsubscribeObjectClass(handle);
setObjectClassSubscribed(i,false);
}
}
}
// Un-publish and un-subscribe all interaction classes
for (unsigned int i = 1; i <= MAX_INTERACTIONS; i++) {
RTI::InteractionClassHandle handle = getInteractionClassHandle(i);
if (handle > 0) {
if (isInteractionClassPublished(i)) {
getRTIambassador()->unpublishInteractionClass(handle);
setInteractionClassPublished(i,false);
}
if (isInteractionClassSubscribed(i)) {
getRTIambassador()->unsubscribeInteractionClass(handle);
setInteractionClassSubscribed(i,false);
}
}
}
}
catch(RTI::Exception& e) {
std::cout << &e << std::endl;
ok = false;
}
return ok;
}
//------------------------------------------------------------------------------
// unregisterAllObjects() --
//------------------------------------------------------------------------------
bool NetIO::unregisterAllObjects()
{
// Stop Registration For Object Classes
clearAllObjectClassRegistrationFlags();
// Unregister all of our output objects ...
for (unsigned int idx = 0; idx < nOutObjects; idx++) {
Nib* nib = outHandleTbl[idx];
if (nib->isRegistered()) {
getRTIambassador()->deleteObjectInstance(nib->getObjectHandle(),0);
nib->setObjectHandle(0);
nib->setClassIndex(0);
}
}
return true;
}
void NetIO::destroyOutputNib(Simulation::Nib* const nib0)
{
std::cout << "NetIO::destroyOutputNib(" << nib0 << ")" << std::endl;
Nib* nib = dynamic_cast<Nib*>(nib0);
if (nib != 0) {
if (nib->isRegistered()) {
// When this output NIB was registered as an HLA object ...
std::cout << "###DeleteReq- Unref-2: handle: " << nib->getObjectHandle() << std::endl;
removeNibFromObjectTables(nib, OUTPUT_NIB);
getRTIambassador()->deleteObjectInstance(nib->getObjectHandle(),0);
nib->setObjectHandle(0);
nib->setClassIndex(0);
}
// Let our base class handle the rest
BaseClass::destroyOutputNib(nib);
}
}
//------------------------------------------------------------------------------
// publishAndSubscribe()
//------------------------------------------------------------------------------
bool NetIO::publishAndSubscribeMunitionDetonation()
{
RTI::RTIambassador* p = getRTIambassador();
bool ok = true;
// ----------
// Get handles to the class, attributes and parameters
// ----------
try {
// ---
// Munition detonation Interaction class handle and parameter handles
// ---
{
RTI::InteractionClassHandle handle =
p->getInteractionClassHandle(MunitionDetonation::getInteractionFedName());
setInteractionClassHandle(MUNITION_DETONATION_INTERACTION, handle );
setInteractionParameterHandle(
DETONATION_LOCATION_MD_PI,
p->getParameterHandle(
MunitionDetonation::getDetonationLocationParameterFedName(),
handle) );
setInteractionParameterHandle(
DETONATION_RESULT_CODE_MD_PI,
p->getParameterHandle(
MunitionDetonation::getDetonationResultCodeParameterFedName(),
handle) );
setInteractionParameterHandle(
EVENT_IDENTIFIER_MD_PI,
p->getParameterHandle(
MunitionDetonation::getEventIdentifierParameterFedName(),
handle) );
setInteractionParameterHandle(
FIRING_OBJECT_IDENTIFIER_MD_PI,
p->getParameterHandle(
MunitionDetonation::getFiringObjectIdentifierParameterFedName(),
handle) );
setInteractionParameterHandle(
FINAL_VELOCITY_VECTOR_MD_PI,
p->getParameterHandle(
MunitionDetonation::getFinalVelocityVectorParameterFedName(),
handle) );
setInteractionParameterHandle(
FUSE_TYPE_MD_PI,
p->getParameterHandle(
MunitionDetonation::getFuseTypeParameterFedName(),
handle) );
setInteractionParameterHandle(
MUNITION_OBJECT_IDENTIFIER_MD_PI,
p->getParameterHandle(
MunitionDetonation::getMunitionObjectIdentifierParameterFedName(),
handle) );
setInteractionParameterHandle(
MUNITION_TYPE_MD_PI,
p->getParameterHandle(
MunitionDetonation::getMunitionTypeParameterFedName(),
handle) );
setInteractionParameterHandle(
QUANTITY_FIRED_MD_PI,
p->getParameterHandle(
MunitionDetonation::getQuantityFiredParameterFedName(),
handle) );
setInteractionParameterHandle(
RATE_OF_FIRE_MD_PI,
p->getParameterHandle(
MunitionDetonation::getRateOfFireParameterFedName(),
handle) );
setInteractionParameterHandle(
RELATIVE_DETONATION_LOCATION_MD_PI,
p->getParameterHandle(
MunitionDetonation::getRelativeDetonationLocationParameterFedName(),
handle) );
setInteractionParameterHandle(
TARGET_OBJECT_IDENTIFIER_MD_PI,
p->getParameterHandle(
MunitionDetonation::getTargetObjectIdentifierParameterFedName(),
handle) );
setInteractionParameterHandle(
WARHEAD_TYPE_MD_PI,
p->getParameterHandle(
MunitionDetonation::getWarheadTypeParameterFedName(),
handle) );
}
}
catch( RTI::Exception& e) {
std::cerr << &e << std::endl;
ok = false;
}
// ----------
// Publish & Subscribe to class attributes
// ----------
if (ok) {
try {
// ---
// Publish these interactions
// ---
if (isOutputEnabled()) {
p->publishInteractionClass(getInteractionClassHandle(MUNITION_DETONATION_INTERACTION));
setInteractionClassPublished(MUNITION_DETONATION_INTERACTION, true);
}
// ---
// Subscribe to these interactions
// ---
if (isInputEnabled()) {
p->subscribeInteractionClass(getInteractionClassHandle(MUNITION_DETONATION_INTERACTION));
setInteractionClassSubscribed(MUNITION_DETONATION_INTERACTION, true);
}
}
catch (RTI::Exception& e) {
std::cerr << &e << std::endl;
ok = false;
}
}
return ok;
}
