00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025 #include "RTI.hh"
00026 #include "fedtime.hh"
00027
00028 #include "RTIambPrivateRefs.hh"
00029 #include "RTItypesImp.hh"
00030
00031 #include "FedRegion.hh"
00032 #include "Message.hh"
00033 #include "PrettyDebug.hh"
00034
00035 #ifdef _WIN32
00036 #include <config.h>
00037 #include <stdio.h>
00038 #include <string.h>
00039 #else
00040 #include <unistd.h>
00041 #endif
00042 #include <iostream>
00043 #include <signal.h>
00044 #include <cassert>
00045 #include <cerrno>
00046 #include <typeinfo>
00047
00048 using std::cout ;
00049 using std::cerr ;
00050 using std::endl ;
00051
00052 namespace {
00053
00054 static pdCDebug D("LIBRTI", __FILE__);
00055 static PrettyDebug G("GENDOC",__FILE__) ;
00056
00057 using namespace certi ;
00058
00059 std::vector<RTI::Handle>
00060 build_region_handles(RTI::Region **regions, int nb)
00061 throw (RTI::RegionNotKnown)
00062 {
00063 std::vector<RTI::Handle> vect(nb);
00064 for (int i = 0 ; i < nb ; ++i) {
00065 RTI::Region *region = regions[i] ;
00066 try {
00067 vect[i] = dynamic_cast<FedRegion *>(region)->getHandle();
00068 }
00069 catch (std::bad_cast) {
00070 throw RTI::RegionNotKnown("");
00071 }
00072 }
00073 return vect ;
00074 }
00075
00076 RTI::Handle
00077 get_handle(const RTI::Region ®ion)
00078 throw (RTI::RegionNotKnown, RTI::RTIinternalError)
00079 {
00080 try {
00081 return dynamic_cast<const FedRegion &>(region).getHandle();
00082 }
00083 catch (std::bad_cast) {
00084 throw RTI::RegionNotKnown("");
00085 }
00086 throw RTI::RTIinternalError("");
00087 }
00088
00089 char *
00090 hla_strdup(const std::string &s)
00091 throw (RTI::RTIinternalError)
00092 {
00093 try {
00094 size_t len = s.length();
00095
00096 char *result = new char[len+1];
00097 strncpy(result, s.c_str(), len);
00098 result[len] = '\0';
00099
00100 return result;
00101 }
00102 catch (std::bad_alloc) {
00103 throw RTI::RTIinternalError("Cannot allocate memory.");
00104 }
00105 throw RTI::RTIinternalError("");
00106 }
00107
00108 }
00109
00110
00112
00117 RTI::RTIambassador::RTIambassador()
00118 throw (RTI::MemoryExhausted, RTI::RTIinternalError)
00119 {
00120 G.Out(pdGendoc,"enter RTIambassador::RTIambassador");
00121 PrettyDebug::setFederateName( "Federate" );
00122 std::stringstream msg;
00123
00124 privateRefs = new RTIambPrivateRefs();
00125
00126 privateRefs->socketUn = new SocketUN(stIgnoreSignal);
00127
00128 privateRefs->is_reentrant = false ;
00129 const char *rtiaexec = "rtia" ;
00130 const char *rtiaenv = getenv("CERTI_RTIA");
00131 const char *rtiacall ;
00132 if (rtiaenv) rtiacall = rtiaenv ;
00133 else rtiacall = rtiaexec ;
00134
00135 #ifdef _WIN32
00136 STARTUPINFO si;
00137 PROCESS_INFORMATION pi;
00138
00139 ZeroMemory( &si, sizeof(si) );
00140 si.cb = sizeof(si);
00141 ZeroMemory( &pi, sizeof(pi) );
00142
00143
00144 if( !CreateProcess( NULL,
00145 (char*)rtiacall,
00146 NULL,
00147 NULL,
00148 FALSE,
00149 0,
00150 NULL,
00151 NULL,
00152 &si,
00153 &pi ))
00154
00155 {
00156 msg << "CreateProcess - GetLastError()=<"
00157 << GetLastError() <<"> "
00158 << "Cannot connect to RTIA.exe";
00159
00160 throw RTI::RTIinternalError( msg.str().c_str());
00161 }
00162
00163 privateRefs->handle_RTIA = pi.hProcess;
00164 privateRefs->pid_RTIA = pi.dwProcessId;
00165
00166 sleep(1);
00167 privateRefs->socketUn->connectUN(privateRefs->pid_RTIA);
00168 #else
00169 sigset_t nset, oset;
00170
00171
00172 sigemptyset(&nset);
00173 sigaddset(&nset, SIGINT);
00174 sigprocmask(SIG_BLOCK, &nset, &oset);
00175
00176 switch((privateRefs->pid_RTIA = fork())) {
00177 case -1:
00178 perror("fork");
00179 throw RTI::RTIinternalError("fork failed in RTIambassador constructor");
00180 break ;
00181
00182 case 0:
00183 execlp(rtiacall, NULL);
00184 msg << "Could not launch RTIA process (execlp): "
00185 << strerror(errno)
00186 << endl
00187 << "Maybe RTIA is not in search PATH environment.";
00188 throw RTI::RTIinternalError(msg.str().c_str());
00189
00190 default:
00191
00192
00193
00194
00195
00196 sleep(1);
00197
00198 if( privateRefs->socketUn->connectUN(privateRefs->pid_RTIA) )
00199 {
00200 D.Out( pdError, "Cannot connect to RTIA. Abort." ) ;
00201 kill( privateRefs->pid_RTIA, SIGINT ) ;
00202 throw RTI::RTIinternalError( "Cannot connect to RTIA" );
00203 };
00204 break ;
00205 }
00206
00207
00208 sigprocmask(SIG_SETMASK, &oset, NULL);
00209 #endif
00210 G.Out(pdGendoc,"exit RTIambassador::RTIambassador");
00211 }
00212
00213
00215
00217 RTI::RTIambassador::~RTIambassador()
00218 throw (RTI::RTIinternalError)
00219 {
00220 Message req, rep ;
00221
00222 req.type = Message::CLOSE_CONNEXION;
00223 G.Out(pdGendoc," ====>executeService CLOSE_CONNEXION");
00224 privateRefs->executeService(&req, &rep);
00225
00226
00227 delete privateRefs;
00228 }
00229
00230
00232
00235 RTI::Boolean
00236 RTI::RTIambassador::tick()
00237 throw (SpecifiedSaveLabelDoesNotExist,
00238 ConcurrentAccessAttempted,
00239 RTI::RTIinternalError)
00240 {
00241 __tick_kernel(RTI_FALSE, 0.0, 0.0);
00242 return RTI_FALSE;
00243 }
00244
00245
00247
00252 RTI::Boolean
00253 RTI::RTIambassador::tick2()
00254 throw (RTI::SpecifiedSaveLabelDoesNotExist,
00255 RTI::ConcurrentAccessAttempted,
00256 RTI::RTIinternalError)
00257 {
00258 __tick_kernel(RTI_FALSE, std::numeric_limits<double>::infinity(), 0.0);
00259 return RTI_FALSE;
00260 }
00261
00262
00264
00269 RTI::Boolean
00270 RTI::RTIambassador::__tick_kernel(RTI::Boolean multiple, TickTime minimum, TickTime maximum)
00271 throw (RTI::SpecifiedSaveLabelDoesNotExist,
00272 RTI::ConcurrentAccessAttempted,
00273 RTI::RTIinternalError)
00274 {
00275 Message vers_RTI, vers_Fed ;
00276
00277
00278 vers_RTI.type = Message::TICK_REQUEST ;
00279 vers_RTI.setBoolean(multiple);
00280 vers_RTI.setMinTickTime(minimum);
00281 vers_RTI.setMaxTickTime(maximum);
00282
00283 try {
00284 vers_RTI.send(privateRefs->socketUn,privateRefs->msgBufSend);
00285 }
00286 catch (NetworkError &e) {
00287 std::stringstream msg;
00288 msg << "NetworkError in tick() while sending TICK_REQUEST: " << e._reason;
00289
00290 throw RTI::RTIinternalError(msg.str().c_str());
00291 }
00292
00293
00294 while (1) {
00295 try {
00296 vers_Fed.receive(privateRefs->socketUn,privateRefs->msgBufReceive);
00297 }
00298 catch (NetworkError &e) {
00299 std::stringstream msg;
00300 msg << "NetworkError in tick() while receiving response: " << e._reason;
00301
00302 throw RTI::RTIinternalError(msg.str().c_str());
00303 }
00304
00305
00306 vers_Fed.trace("RTI::RTIambassador::tick ");
00307
00308
00309 if (vers_Fed.type == Message::TICK_REQUEST) {
00310 if (vers_Fed.getExceptionType() != e_NO_EXCEPTION) {
00311
00312
00313 privateRefs->processException(&vers_Fed);
00314 }
00315 return RTI::Boolean(vers_Fed.getBoolean());
00316 }
00317
00318 try {
00319
00320 privateRefs->callFederateAmbassador(&vers_Fed);
00321 }
00322 catch (RTI::RTIinternalError) {
00323
00324 privateRefs->sendTickRequestStop();
00325
00326 throw;
00327 }
00328
00329 try {
00330
00331 Message tick_next;
00332 tick_next.type = Message::TICK_REQUEST_NEXT;
00333
00334 tick_next.send(privateRefs->socketUn, privateRefs->msgBufSend);
00335 }
00336 catch (NetworkError &e) {
00337 std::stringstream msg;
00338 msg << "NetworkError in tick() while sending TICK_REQUEST_NEXT: " << e._reason;
00339
00340 throw RTI::RTIinternalError(msg.str().c_str());
00341 }
00342 }
00343 }
00344
00345
00347
00352 RTI::Boolean
00353 RTI::RTIambassador::tick(TickTime minimum, TickTime maximum)
00354 throw (RTI::SpecifiedSaveLabelDoesNotExist, RTI::ConcurrentAccessAttempted,
00355 RTI::RTIinternalError)
00356 {
00357 return __tick_kernel(RTI_TRUE, minimum, maximum);
00358 }
00359
00360
00362 RTI::RegionToken
00363 RTI::RTIambassador::getRegionToken(Region *region)
00364 throw (RTI::FederateNotExecutionMember, RTI::ConcurrentAccessAttempted,
00365 RTI::RegionNotKnown, RTI::RTIinternalError)
00366 {
00367 return get_handle(*region);
00368 }
00369
00370
00372 RTI::Region *
00373 RTI::RTIambassador::getRegion(RegionToken)
00374 throw (RTI::FederateNotExecutionMember, RTI::ConcurrentAccessAttempted,
00375 RTI::RegionNotKnown, RTI::RTIinternalError)
00376 {
00377 throw RTI::RTIinternalError("unimplemented service getRegion");
00378 }
00379
00380
00381
00389 void
00390
00391 RTI::RTIambassador::createFederationExecution(const char *executionName,
00392 const char *FED)
00393 throw (RTI::RTIinternalError, RTI::ConcurrentAccessAttempted,
00394 RTI::ErrorReadingFED, RTI::CouldNotOpenFED,
00395 RTI::FederationExecutionAlreadyExists)
00396 {
00397 Message req, rep ;
00398
00399 G.Out(pdGendoc,"enter RTIambassador::createFederationExecution");
00400
00401 req.type = Message::CREATE_FEDERATION_EXECUTION ;
00402 req.setFederationName(executionName);
00403 req.setFEDid(FED);
00404
00405
00406
00407
00408
00409
00410
00411 G.Out(pdGendoc," ====>executeService CREATE_FEDERATION_EXECUTION");
00412
00413 privateRefs->executeService(&req, &rep);
00414
00415 G.Out(pdGendoc,"exit RTIambassador::createFederationExecution");
00416
00417 }
00418
00419
00420
00427 void
00428 RTI::RTIambassador::destroyFederationExecution(const char *executionName)
00429 throw (RTI::RTIinternalError, RTI::ConcurrentAccessAttempted,
00430 RTI::FederationExecutionDoesNotExist, RTI::FederatesCurrentlyJoined)
00431 {
00432 Message req, rep ;
00433
00434 G.Out(pdGendoc,"enter RTIambassador::destroyFederationExecution");
00435
00436 req.type = Message::DESTROY_FEDERATION_EXECUTION ;
00437 req.setFederationName(executionName);
00438
00439 G.Out(pdGendoc," ====>executeService DESTROY_FEDERATION_EXECUTION");
00440
00441 privateRefs->executeService(&req, &rep);
00442
00443 G.Out(pdGendoc,"exit RTIambassador::destroyFederationExecution");
00444
00445 }
00446
00447
00449 FederateHandle
00450 RTI::RTIambassador::joinFederationExecution(const char *yourName,
00451 const char *executionName,
00452 FederateAmbassadorPtr fedamb)
00453 throw (RTI::RTIinternalError, RTI::RestoreInProgress, RTI::SaveInProgress,
00454 RTI::ConcurrentAccessAttempted, RTI::ErrorReadingFED, RTI::CouldNotOpenFED,
00455 RTI::FederationExecutionDoesNotExist, RTI::FederateAlreadyExecutionMember)
00456 {
00457 Message req, rep ;
00458
00459 G.Out(pdGendoc,"enter RTIambassador::joinFederationExecution");
00460
00461 if ( yourName == NULL || strlen(yourName) == 0 )
00462 throw RTI::RTIinternalError("Incorrect or empty federate name");
00463 if ( executionName == NULL || strlen(executionName) == 0 )
00464 throw RTI::RTIinternalError("Incorrect or empty federation name");
00465
00466 privateRefs->fed_amb = (FederateAmbassador *) fedamb ;
00467
00468 req.type = Message::JOIN_FEDERATION_EXECUTION ;
00469 req.setFederateName(yourName);
00470 req.setFederationName(executionName);
00471 G.Out(pdGendoc," ====>executeService JOIN_FEDERATION_EXECUTION");
00472 privateRefs->executeService(&req, &rep);
00473 G.Out(pdGendoc,"exit RTIambassador::joinFederationExecution");
00474 return rep.getFederate();
00475 }
00476
00477
00479 void
00480 RTI::RTIambassador::resignFederationExecution(ResignAction theAction)
00481 throw (RTI::FederateOwnsAttributes,
00482 RTI::FederateNotExecutionMember,
00483 RTI::InvalidResignAction,
00484 RTI::ConcurrentAccessAttempted,
00485 RTI::RTIinternalError)
00486 {
00487 Message req, rep ;
00488
00489 G.Out(pdGendoc,"enter RTIambassador::resignFederationExecution");
00490
00491 req.type = Message::RESIGN_FEDERATION_EXECUTION ;
00492 req.setResignAction(theAction);
00493
00494 G.Out(pdGendoc," ====>executeService RESIGN_FEDERATION_EXECUTION");
00495 privateRefs->executeService(&req, &rep);
00496
00497 G.Out(pdGendoc,"exit RTIambassador::resignFederationExecution");
00498
00499 }
00500
00501
00503
00508 void
00509 RTI::RTIambassador::registerFederationSynchronizationPoint(const char *label,
00510 const char *the_tag)
00511 throw (RTI::FederateNotExecutionMember,
00512 RTI::ConcurrentAccessAttempted,
00513 RTI::SaveInProgress,
00514 RTI::RestoreInProgress,
00515 RTI::RTIinternalError)
00516 {
00517 Message req, rep ;
00518
00519 G.Out(pdGendoc,"enter RTIambassador::registerFederationSynchronizationPoint for all federates");
00520
00521 req.type = Message::REGISTER_FEDERATION_SYNCHRONIZATION_POINT ;
00522 req.setLabel(label);
00523 if ( the_tag == NULL )
00524 {
00525 throw RTI::RTIinternalError ("Calling registerFederationSynchronizationPoint with Tag NULL");
00526 }
00527 req.setTag(the_tag);
00528
00529 req.setBoolean(false);
00530 G.Out(pdGendoc," ====>executeService REGISTER_FEDERATION_SYNCHRONIZATION_POINT");
00531 privateRefs->executeService(&req, &rep);
00532
00533 G.Out(pdGendoc,"exit RTIambassador::registerFederationSynchronizationPoint for all federates");
00534
00535 }
00536
00537
00539
00545 void
00546 RTI::RTIambassador::registerFederationSynchronizationPoint(const char *label,
00547 const char *theTag,
00548 const FederateHandleSet &set_of_fed)
00549 throw (RTI::RTIinternalError, RTI::RestoreInProgress, RTI::SaveInProgress,
00550 RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember)
00551 {
00552
00553 Message req, rep ;
00554
00555 G.Out(pdGendoc,"enter RTIambassador::registerFederationSynchronizationPoint for some federates");
00556
00557 req.type = Message::REGISTER_FEDERATION_SYNCHRONIZATION_POINT ;
00558 req.setLabel(label);
00559 if ( theTag == NULL )
00560 {
00561 throw RTI::RTIinternalError ("Calling registerFederationSynchronizationPoint with Tag NULL");
00562 }
00563 req.setTag(theTag);
00564
00565
00566 if ( set_of_fed.size() == 0 )
00567 {
00568 req.setBoolean(false) ;
00569 }
00570 else
00571 {
00572 req.setBoolean(true);
00573
00574 req.handleArraySize = set_of_fed.size() ;
00575 req.handleArray.resize(req.handleArraySize) ;
00576 for (unsigned long i=0 ; i<set_of_fed.size() ; i++)
00577 {
00578 req.handleArray[i] = set_of_fed.getHandle(i) ;
00579 }
00580 }
00581 G.Out(pdGendoc," ====>executeService REGISTER_FEDERATION_SYNCHRONIZATION_POINT");
00582 privateRefs->executeService(&req, &rep);
00583
00584 G.Out(pdGendoc,"exit RTIambassador::registerFederationSynchronizationPoint for some federates");
00585
00586 }
00587
00588
00590 void
00591 RTI::RTIambassador::synchronizationPointAchieved(const char *label)
00592 throw (RTI::SynchronizationPointLabelWasNotAnnounced,
00593 RTI::FederateNotExecutionMember,
00594 RTI::ConcurrentAccessAttempted,
00595 RTI::SaveInProgress,
00596 RTI::RestoreInProgress,
00597 RTI::RTIinternalError)
00598 {
00599 Message req, rep ;
00600
00601 G.Out(pdGendoc,"enter RTIambassador::synchronizationPointAchieved");
00602
00603 req.type = Message::SYNCHRONIZATION_POINT_ACHIEVED ;
00604 req.setLabel(label);
00605 G.Out(pdGendoc," ====>executeService SYNCHRONIZATION_POINT_ACHIEVED");
00606 privateRefs->executeService(&req, &rep);
00607
00608 G.Out(pdGendoc,"exit RTIambassador::synchronizationPointAchieved");
00609 }
00610
00611
00613 void
00614 RTI::RTIambassador::requestFederationSave(const char *label,
00615 const RTI::FedTime& theTime)
00616 throw (RTI::FederationTimeAlreadyPassed,
00617 RTI::InvalidFederationTime,
00618 RTI::FederateNotExecutionMember,
00619 RTI::ConcurrentAccessAttempted,
00620 RTI::SaveInProgress,
00621 RTI::RestoreInProgress,
00622 RTI::RTIinternalError)
00623 {
00624 Message req, rep ;
00625
00626 G.Out(pdGendoc,"enter RTIambassador::requestFederationSave with time");
00627
00628 req.type = Message::REQUEST_FEDERATION_SAVE ;
00629 req.setFedTime(certi_cast<RTIfedTime>()(theTime).getTime());
00630 req.setLabel(label);
00631
00632 req.setBoolean(true);
00633
00634 G.Out(pdGendoc," ====>executeService REQUEST_FEDERATION_SAVE");
00635 privateRefs->executeService(&req, &rep);
00636
00637 G.Out(pdGendoc,"exit RTIambassador::requestFederationSave with time");
00638 }
00639
00640
00642 void
00643 RTI::RTIambassador::requestFederationSave(const char *label)
00644 throw (RTI::FederateNotExecutionMember,
00645 RTI::ConcurrentAccessAttempted,
00646 RTI::SaveInProgress,
00647 RTI::RestoreInProgress,
00648 RTI::RTIinternalError)
00649 {
00650 Message req, rep ;
00651
00652 G.Out(pdGendoc,"enter RTIambassador::requestFederationSave without time");
00653
00654 req.type = Message::REQUEST_FEDERATION_SAVE ;
00655 req.setLabel(label);
00656
00657 req.setBoolean(false);
00658
00659 G.Out(pdGendoc," ====>executeService REQUEST_FEDERATION_SAVE");
00660
00661 privateRefs->executeService(&req, &rep);
00662
00663 G.Out(pdGendoc,"exit RTIambassador::requestFederationSave without time");
00664 }
00665
00666
00668 void
00669 RTI::RTIambassador::federateSaveBegun()
00670 throw (RTI::SaveNotInitiated,
00671 RTI::FederateNotExecutionMember,
00672 RTI::ConcurrentAccessAttempted,
00673 RTI::RestoreInProgress,
00674 RTI::RTIinternalError)
00675 {
00676 Message req, rep ;
00677
00678 G.Out(pdGendoc,"enter RTIambassador::federateSaveBegun");
00679
00680 req.type = Message::FEDERATE_SAVE_BEGUN ;
00681 G.Out(pdGendoc," ====>executeService FEDERATE_SAVE_BEGUN");
00682 privateRefs->executeService(&req, &rep);
00683
00684 G.Out(pdGendoc,"exit RTIambassador::federateSaveBegun");
00685 }
00686
00687
00689 void
00690 RTI::RTIambassador::federateSaveComplete()
00691 throw (RTI::SaveNotInitiated,
00692 RTI::FederateNotExecutionMember,
00693 RTI::ConcurrentAccessAttempted,
00694 RTI::RestoreInProgress,
00695 RTI::RTIinternalError)
00696 {
00697 Message req, rep ;
00698
00699 G.Out(pdGendoc,"enter RTIambassador::federateSaveComplete");
00700
00701 req.type = Message::FEDERATE_SAVE_COMPLETE ;
00702 G.Out(pdGendoc," ====>executeService FEDERATE_SAVE_COMPLETE");
00703 privateRefs->executeService(&req, &rep);
00704 G.Out(pdGendoc,"exit RTIambassador::federateSaveComplete");
00705 }
00706
00707
00708
00709 void
00710 RTI::RTIambassador::federateSaveNotComplete()
00711 throw (RTI::SaveNotInitiated,
00712 RTI::FederateNotExecutionMember,
00713 RTI::ConcurrentAccessAttempted,
00714 RTI::RestoreInProgress,
00715 RTI::RTIinternalError)
00716 {
00717
00718 Message req, rep ;
00719
00720 G.Out(pdGendoc,"enter RTIambassador::federateSaveNotComplete");
00721 G.Out(pdGendoc," ====>executeService FEDERATE_SAVE_NOT_COMPLETE");
00722 req.type = Message::FEDERATE_SAVE_NOT_COMPLETE ;
00723
00724 privateRefs->executeService(&req, &rep);
00725
00726 G.Out(pdGendoc,"exit RTIambassador::federateSaveNotComplete");
00727 }
00728
00729
00731 void
00732 RTI::RTIambassador::requestFederationRestore(const char *label)
00733 throw (RTI::RTIinternalError, RTI::RestoreInProgress, RTI::SaveInProgress,
00734 RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember)
00735 {
00736 Message req, rep ;
00737
00738 G.Out(pdGendoc,"enter RTIambassador::requestFederationRestore");
00739
00740 req.type = Message::REQUEST_FEDERATION_RESTORE ;
00741 req.setLabel(label);
00742 G.Out(pdGendoc," ====>executeService REQUEST_FEDERATION_RESTORE");
00743 privateRefs->executeService(&req, &rep);
00744 G.Out(pdGendoc,"exit RTIambassador::requestFederationRestore");
00745 }
00746
00747
00749 void
00750 RTI::RTIambassador::federateRestoreComplete()
00751 throw (RTI::RTIinternalError, RTI::SaveInProgress,
00752 RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember,
00753 RTI::RestoreNotRequested)
00754 {
00755 Message req, rep ;
00756
00757 G.Out(pdGendoc,"enter RTIambassador::federateRestoreComplete");
00758
00759 req.type = Message::FEDERATE_RESTORE_COMPLETE ;
00760 G.Out(pdGendoc," ====>executeService FEDERATE_RESTORE_COMPLETE");
00761 privateRefs->executeService(&req, &rep);
00762 G.Out(pdGendoc,"exit RTIambassador::federateRestoreComplete");
00763 }
00764
00765
00767 void
00768 RTI::RTIambassador::federateRestoreNotComplete()
00769 throw (RTI::RTIinternalError, RTI::SaveInProgress,
00770 RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember,
00771 RTI::RestoreNotRequested)
00772 {
00773 Message req, rep ;
00774
00775 G.Out(pdGendoc,"enter RTIambassador::federateRestoreNotComplete");
00776 G.Out(pdGendoc," ====>executeService FEDERATE_RESTORE_NOT_COMPLETE");
00777 req.type = Message::FEDERATE_RESTORE_NOT_COMPLETE ;
00778
00779 privateRefs->executeService(&req, &rep);
00780 G.Out(pdGendoc,"exit RTIambassador::federateRestoreNotComplete");
00781 }
00782
00783
00784
00785 void
00786 RTI::RTIambassador::publishObjectClass(ObjectClassHandle theClass,
00787 const AttributeHandleSet& attributeList)
00788 throw (RTI::RTIinternalError,
00789 RTI::RestoreInProgress, RTI::SaveInProgress, RTI::ConcurrentAccessAttempted,
00790 RTI::FederateNotExecutionMember, RTI::OwnershipAcquisitionPending,
00791 RTI::AttributeNotDefined, RTI::ObjectClassNotDefined)
00792 {
00793 Message req, rep ;
00794
00795 G.Out(pdGendoc,"enter RTIambassador::publishObjectClass");
00796
00797 req.type = Message::PUBLISH_OBJECT_CLASS ;
00798 req.setObjectClass(theClass);
00799 req.setAHS(certi_cast<AttributeHandleSetImp>()(attributeList).getAttributeHandles());
00800 G.Out(pdGendoc," ====>executeService PUBLISH_OBJECT_CLASS");
00801 privateRefs->executeService(&req, &rep);
00802 G.Out(pdGendoc,"exit RTIambassador::publishObjectClass");
00803 }
00804
00805
00806
00807 void
00808 RTI::RTIambassador::unpublishObjectClass(ObjectClassHandle theClass)
00809 throw (RTI::RTIinternalError, RTI::RestoreInProgress, RTI::SaveInProgress,
00810 RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember,
00811 RTI::OwnershipAcquisitionPending, RTI::ObjectClassNotPublished,
00812 RTI::ObjectClassNotDefined)
00813 {
00814 Message req, rep ;
00815
00816 G.Out(pdGendoc,"enter RTIambassador::unpublishObjectClass");
00817
00818 req.type = Message::UNPUBLISH_OBJECT_CLASS ;
00819 req.setObjectClass(theClass);
00820 G.Out(pdGendoc," ====>executeService UNPUBLISH_OBJECT_CLASS");
00821 privateRefs->executeService(&req, &rep);
00822 G.Out(pdGendoc,"exit RTIambassador::unpublishObjectClass");
00823 }
00824
00825
00826
00827
00828 void
00829 RTI::RTIambassador::publishInteractionClass(InteractionClassHandle theInteraction)
00830 throw (RTI::RTIinternalError, RTI::RestoreInProgress, RTI::SaveInProgress,
00831 RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember,
00832 RTI::InteractionClassNotDefined)
00833 {
00834 Message req, rep ;
00835
00836 req.type = Message::PUBLISH_INTERACTION_CLASS ;
00837 req.setInteractionClass(theInteraction);
00838 G.Out(pdGendoc," ====>executeService PUBLISH_INTERACTION_CLASS");
00839 privateRefs->executeService(&req, &rep);
00840 }
00841
00842
00843
00844 void
00845 RTI::RTIambassador::unpublishInteractionClass(InteractionClassHandle theInteraction)
00846 throw (RTI::RTIinternalError, RTI::RestoreInProgress, RTI::SaveInProgress,
00847 RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember,
00848 RTI::InteractionClassNotPublished, RTI::InteractionClassNotDefined)
00849 {
00850 Message req, rep ;
00851
00852 req.type = Message::UNPUBLISH_INTERACTION_CLASS ;
00853 req.setInteractionClass(theInteraction);
00854 privateRefs->executeService(&req, &rep);
00855 }
00856
00857
00858
00859 void
00860 RTI::RTIambassador::
00861 subscribeObjectClassAttributes(ObjectClassHandle theClass,
00862 const AttributeHandleSet& attributeList,
00863 RTI::Boolean active)
00864 throw (RTI::RTIinternalError,
00865 RTI::RestoreInProgress, RTI::SaveInProgress, RTI::ConcurrentAccessAttempted,
00866 RTI::FederateNotExecutionMember, RTI::AttributeNotDefined,
00867 RTI::ObjectClassNotDefined)
00868 {
00869 Message req, rep ;
00870 G.Out(pdGendoc,"enter RTIambassador::subscribeObjectClassAttributes");
00871 req.type = Message::SUBSCRIBE_OBJECT_CLASS_ATTRIBUTES ;
00872 req.setObjectClass(theClass);
00873 req.setAHS(certi_cast<AttributeHandleSetImp>()(attributeList).getAttributeHandles());
00874 req.setBoolean(active);
00875
00876 privateRefs->executeService(&req, &rep);
00877 G.Out(pdGendoc,"exit RTIambassador::subscribeObjectClassAttributes");
00878 }
00879
00880
00881
00882 void
00883 RTI::RTIambassador::unsubscribeObjectClass(ObjectClassHandle theClass)
00884 throw (RTI::RTIinternalError, RTI::RestoreInProgress, RTI::SaveInProgress,
00885 RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember,
00886 RTI::ObjectClassNotSubscribed, RTI::ObjectClassNotDefined)
00887 {
00888 Message req, rep ;
00889
00890 req.type = Message::UNSUBSCRIBE_OBJECT_CLASS ;
00891 req.setObjectClass(theClass);
00892 privateRefs->executeService(&req, &rep);
00893 }
00894
00895
00896
00897
00898 void
00899 RTI::RTIambassador::subscribeInteractionClass(InteractionClassHandle theClass,
00900 RTI::Boolean )
00901 throw (RTI::RTIinternalError, RTI::RestoreInProgress,
00902 RTI::SaveInProgress, RTI::FederateLoggingServiceCalls,
00903 RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember,
00904 RTI::InteractionClassNotDefined)
00905 {
00906 Message req, rep ;
00907
00908 req.type = Message::SUBSCRIBE_INTERACTION_CLASS ;
00909 req.setInteractionClass(theClass);
00910 privateRefs->executeService(&req, &rep);
00911 }
00912
00913
00914
00915 void
00916 RTI::RTIambassador::unsubscribeInteractionClass(InteractionClassHandle theClass)
00917 throw (RTI::RTIinternalError, RTI::RestoreInProgress, RTI::SaveInProgress,
00918 RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember,
00919 RTI::InteractionClassNotSubscribed, RTI::InteractionClassNotDefined)
00920 {
00921 Message req, rep ;
00922
00923 req.type = Message::UNSUBSCRIBE_INTERACTION_CLASS ;
00924 req.setInteractionClass(theClass);
00925 privateRefs->executeService(&req, &rep);
00926 }
00927
00928
00929
00930 ObjectHandle
00931 RTI::RTIambassador::registerObjectInstance(ObjectClassHandle theClass,
00932 const char *theObjectName)
00933 throw (RTI::RTIinternalError, RTI::RestoreInProgress,
00934 RTI::SaveInProgress, RTI::ConcurrentAccessAttempted,
00935 RTI::FederateNotExecutionMember, RTI::ObjectAlreadyRegistered,
00936 RTI::ObjectClassNotPublished, RTI::ObjectClassNotDefined)
00937 {
00938 Message req, rep ;
00939
00940 req.type = Message::REGISTER_OBJECT_INSTANCE ;
00941 req.setName(theObjectName);
00942 req.setObjectClass(theClass);
00943 privateRefs->executeService(&req, &rep);
00944
00945 return rep.getObject();
00946 }
00947
00948
00949 ObjectHandle
00950 RTI::RTIambassador::registerObjectInstance(ObjectClassHandle theClass)
00951 throw (RTI::RTIinternalError, RTI::RestoreInProgress, RTI::SaveInProgress,
00952 RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember,
00953 RTI::ObjectClassNotPublished, RTI::ObjectClassNotDefined)
00954 {
00955 Message req, rep ;
00956
00957 req.type = Message::REGISTER_OBJECT_INSTANCE ;
00958 req.setName("\0");
00959 req.setObjectClass(theClass);
00960
00961 privateRefs->executeService(&req, &rep);
00962
00963 return rep.getObject();
00964 }
00965
00966
00967
00978 RTI::EventRetractionHandle
00979 RTI::RTIambassador::
00980 updateAttributeValues(ObjectHandle theObject,
00981 const AttributeHandleValuePairSet& theAttributes,
00982 const RTI::FedTime& theTime,
00983 const char *theTag)
00984 throw (RTI::ObjectNotKnown,
00985 RTI::AttributeNotDefined,
00986 RTI::AttributeNotOwned,
00987 RTI::InvalidFederationTime,
00988 RTI::FederateNotExecutionMember,
00989 RTI::ConcurrentAccessAttempted,
00990 RTI::SaveInProgress,
00991 RTI::RestoreInProgress,
00992 RTI::RTIinternalError)
00993 {
00994 G.Out(pdGendoc,"enter RTIambassador::updateAttributeValues with time");
00995 Message req, rep ;
00996
00997 req.type = Message::UPDATE_ATTRIBUTE_VALUES ;
00998 req.setObject(theObject);
00999 req.setFedTime(certi_cast<RTIfedTime>()(theTime).getTime());
01000 if ( theTag == NULL)
01001 {
01002 throw RTI::RTIinternalError ("Calling updateAttributeValues with Tag NULL");
01003 }
01004 req.setTag(theTag);
01005 req.setAHVPS(certi_cast<AttributeHandleValuePairSetImp>()(theAttributes).getAttributeHandleValuePairs());
01006 req.setBoolean(true);
01007
01008 privateRefs->executeService(&req, &rep);
01009 G.Out(pdGendoc,"return RTIambassador::updateAttributeValues with time");
01010 return rep.getEventRetraction();
01011 }
01012
01013
01014
01023 void
01024 RTI::RTIambassador::updateAttributeValues(ObjectHandle the_object,
01025 const AttributeHandleValuePairSet& theAttributes,
01026 const char *theTag)
01027 throw (RTI::RTIinternalError, RTI::RestoreInProgress, RTI::SaveInProgress,
01028 RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember,
01029 RTI::AttributeNotOwned, RTI::AttributeNotDefined, RTI::ObjectNotKnown)
01030 {
01031 G.Out(pdGendoc,"enter RTIambassador::updateAttributeValues without time");
01032 Message req, rep ;
01033
01034 req.type = Message::UPDATE_ATTRIBUTE_VALUES ;
01035 req.setObject(the_object);
01036 if ( theTag == NULL)
01037 {
01038 throw RTI::RTIinternalError ("Calling updateAttributeValues with Tag NULL");
01039 }
01040 req.setTag(theTag);
01041 req.setAHVPS(certi_cast<AttributeHandleValuePairSetImp>()(theAttributes).getAttributeHandleValuePairs());
01042 req.setBoolean(false);
01043
01044 privateRefs->executeService(&req, &rep);
01045 G.Out(pdGendoc,"exit RTIambassador::updateAttributeValues without time");
01046 }
01047
01048
01057 RTI::EventRetractionHandle
01058 RTI::RTIambassador::sendInteraction(InteractionClassHandle theInteraction,
01059 const ParameterHandleValuePairSet& theParameters,
01060 const RTI::FedTime& theTime,
01061 const char *theTag)
01062 throw (RTI::InteractionClassNotDefined,
01063 RTI::InteractionClassNotPublished,
01064 RTI::InteractionParameterNotDefined,
01065 RTI::InvalidFederationTime,
01066 RTI::FederateNotExecutionMember,
01067 RTI::ConcurrentAccessAttempted,
01068 RTI::SaveInProgress,
01069 RTI::RestoreInProgress,
01070 RTI::RTIinternalError)
01071 {
01072 Message req, rep ;
01073
01074 req.type = Message::SEND_INTERACTION ;
01075 req.setInteractionClass(theInteraction);
01076 req.setFedTime(certi_cast<RTIfedTime>()(theTime).getTime());
01077 if (theTag == NULL)
01078 {
01079 throw RTI::RTIinternalError ("Calling sendInteraction with Tag NULL") ;
01080 }
01081 req.setTag((std::string)theTag);
01082 req.setPHVPS(certi_cast<ParameterHandleValuePairSetImp>()(theParameters).getParameterHandleValuePairs());
01083 req.setRegion(0);
01084 req.setBoolean(true);
01085
01086 privateRefs->executeService(&req, &rep);
01087
01088 return rep.getEventRetraction();
01089 }
01090
01091
01099 void
01100 RTI::RTIambassador::sendInteraction(InteractionClassHandle theInteraction,
01101 const ParameterHandleValuePairSet &theParameters,
01102 const char *theTag)
01103 throw (RTI::RTIinternalError, RTI::RestoreInProgress, RTI::SaveInProgress,
01104 RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember,
01105 RTI::InteractionParameterNotDefined, RTI::InteractionClassNotPublished,
01106 RTI::InteractionClassNotDefined)
01107 {
01108
01109 Message req, rep ;
01110
01111 req.type = Message::SEND_INTERACTION ;
01112 req.setInteractionClass(theInteraction);
01113 if (theTag == NULL)
01114 {
01115 throw RTI::RTIinternalError ("Calling sendIntercation with Tag NULL") ;
01116 }
01117 req.setTag((std::string)theTag);
01118 req.setPHVPS(certi_cast<ParameterHandleValuePairSetImp>()(theParameters).getParameterHandleValuePairs());
01119 req.setRegion(0);
01120 req.setBoolean(false);
01121
01122 privateRefs->executeService(&req, &rep);
01123 }
01124
01125
01133 RTI::EventRetractionHandle
01134 RTI::RTIambassador::deleteObjectInstance(ObjectHandle theObject,
01135 const RTI::FedTime& theTime,
01136 const char *theTag)
01137 throw (RTI::ObjectNotKnown,
01138 RTI::DeletePrivilegeNotHeld,
01139 RTI::InvalidFederationTime,
01140 RTI::FederateNotExecutionMember,
01141 RTI::ConcurrentAccessAttempted,
01142 RTI::SaveInProgress,
01143 RTI::RestoreInProgress,
01144 RTI::RTIinternalError)
01145 {
01146 Message req, rep ;
01147
01148 req.type = Message::DELETE_OBJECT_INSTANCE ;
01149 req.setObject(theObject);
01150 req.setFedTime(certi_cast<RTIfedTime>()(theTime).getTime());
01151 if (theTag == NULL)
01152 {
01153 throw RTI::RTIinternalError ("Calling deleteObjectInstance with Tag NULL") ;
01154 }
01155 req.setTag(theTag);
01156 req.setBoolean(true);
01157
01158 privateRefs->executeService(&req, &rep);
01159 return rep.getEventRetraction();
01160 }
01161
01162
01168 void
01169 RTI::RTIambassador::deleteObjectInstance(ObjectHandle theObject,
01170 const char *theTag)
01171 throw (RTI::RTIinternalError, RTI::RestoreInProgress, RTI::SaveInProgress,
01172 RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember,
01173 RTI::DeletePrivilegeNotHeld, RTI::ObjectNotKnown)
01174 {
01175 Message req, rep ;
01176
01177 req.type = Message::DELETE_OBJECT_INSTANCE ;
01178 req.setObject(theObject);
01179 if (theTag == NULL)
01180 {
01181 throw RTI::RTIinternalError ("Calling deleteObjectInstance with Tag NULL") ;
01182 }
01183 req.setTag(theTag);
01184
01185 req.setBoolean(false);
01186
01187 privateRefs->executeService(&req, &rep);
01188 }
01189
01190
01191
01192 void
01193 RTI::RTIambassador::localDeleteObjectInstance(ObjectHandle theObject)
01194 throw (RTI::RTIinternalError, RTI::RestoreInProgress, RTI::SaveInProgress,
01195 RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember,
01196 RTI::FederateOwnsAttributes, RTI::ObjectNotKnown)
01197 {
01198 throw RTI::RTIinternalError("unimplemented service localDeleteObjectInstance");
01199 Message req, rep ;
01200
01201 req.type = Message::LOCAL_DELETE_OBJECT_INSTANCE ;
01202 req.setObject(theObject);
01203
01204 privateRefs->executeService(&req, &rep);
01205 }
01206
01207
01208
01209
01210 void
01211 RTI::RTIambassador::
01212 changeAttributeTransportationType(ObjectHandle theObject,
01213 const AttributeHandleSet& theAttributes,
01214 TransportationHandle theType)
01215 throw (RTI::RTIinternalError, RTI::RestoreInProgress, RTI::SaveInProgress,
01216 RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember,
01217 RTI::InvalidTransportationHandle, RTI::AttributeNotOwned,
01218 RTI::AttributeNotDefined, RTI::ObjectNotKnown)
01219 {
01220 Message req, rep ;
01221
01222 req.type = Message::CHANGE_ATTRIBUTE_TRANSPORTATION_TYPE ;
01223 req.setObject(theObject);
01224 req.setTransportation(theType);
01225 req.setAHS(certi_cast<AttributeHandleSetImp>()(theAttributes).getAttributeHandles());
01226
01227 privateRefs->executeService(&req, &rep);
01228 }
01229
01230
01231
01232 void
01233 RTI::RTIambassador::
01234 changeInteractionTransportationType(InteractionClassHandle theClass,
01235 TransportationHandle theType)
01236 throw (RTI::RTIinternalError, RTI::RestoreInProgress,
01237 RTI::SaveInProgress, RTI::ConcurrentAccessAttempted,
01238 RTI::FederateNotExecutionMember, RTI::InvalidTransportationHandle,
01239 RTI::InteractionClassNotPublished, RTI::InteractionClassNotDefined)
01240 {
01241 Message req, rep ;
01242
01243 req.type = Message::CHANGE_INTERACTION_TRANSPORTATION_TYPE ;
01244 req.setInteractionClass(theClass);
01245 req.setTransportation(theType);
01246
01247 privateRefs->executeService(&req, &rep);
01248 }
01249
01250
01251
01252 void
01253 RTI::RTIambassador::requestObjectAttributeValueUpdate(ObjectHandle theObject,
01254 const AttributeHandleSet &ahs)
01255 throw (RTI::RTIinternalError,
01256 RTI::RestoreInProgress, RTI::SaveInProgress, RTI::ConcurrentAccessAttempted,
01257 RTI::FederateNotExecutionMember, RTI::AttributeNotDefined,
01258 RTI::ObjectNotKnown)
01259 {
01260 Message req, rep ;
01261
01262 G.Out(pdGendoc,"enter RTIambassador::requestObjectAttributeValueUpdate");
01263 req.type = Message::REQUEST_OBJECT_ATTRIBUTE_VALUE_UPDATE ;
01264 req.setObject(theObject);
01265 req.setAHS(certi_cast<AttributeHandleSetImp>()(ahs).getAttributeHandles());
01266
01267 privateRefs->executeService(&req, &rep);
01268 G.Out(pdGendoc,"exit RTIambassador::requestObjectAttributeValueUpdate");
01269 }
01270
01271
01272 void
01273 RTI::RTIambassador::requestClassAttributeValueUpdate(ObjectClassHandle theClass,
01274 const AttributeHandleSet &attrs)
01275 throw (RTI::RTIinternalError,
01276 RTI::RestoreInProgress, RTI::SaveInProgress, RTI::ConcurrentAccessAttempted,
01277 RTI::FederateNotExecutionMember, RTI::AttributeNotDefined,
01278 RTI::ObjectClassNotDefined)
01279 {
01280
01281 Message req, rep ;
01282
01283 G.Out(pdGendoc,"enter RTIambassador::requestClassAttributeValueUpdate");
01284 req.type = Message::REQUEST_CLASS_ATTRIBUTE_VALUE_UPDATE ;
01285 req.setObjectClass(theClass);
01286 req.setAHS(certi_cast<AttributeHandleSetImp>()(attrs).getAttributeHandles());
01287
01288 privateRefs->executeService(&req, &rep);
01289 G.Out(pdGendoc,"exit RTIambassador::requestClassAttributeValueUpdate");
01290 }
01291
01292
01293
01294 void
01295 RTI::RTIambassador::
01296 unconditionalAttributeOwnershipDivestiture(ObjectHandle theObject,
01297 const AttributeHandleSet &attrs)
01298 throw (RTI::ObjectNotKnown,
01299 RTI::AttributeNotDefined,
01300 RTI::AttributeNotOwned,
01301 RTI::FederateNotExecutionMember,
01302 RTI::ConcurrentAccessAttempted,
01303 RTI::SaveInProgress,
01304 RTI::RestoreInProgress,
01305 RTI::RTIinternalError)
01306 {
01307 Message req, rep ;
01308
01309 req.type = Message::UNCONDITIONAL_ATTRIBUTE_OWNERSHIP_DIVESTITURE ;
01310 req.setObject(theObject);
01311 req.setAHS(certi_cast<AttributeHandleSetImp>()(attrs).getAttributeHandles());
01312
01313 privateRefs->executeService(&req, &rep);
01314 }
01315
01316
01317
01318 void
01319 RTI::RTIambassador::
01320 negotiatedAttributeOwnershipDivestiture(ObjectHandle theObject,
01321 const AttributeHandleSet& attrs,
01322 const char *theTag)
01323 throw (RTI::ObjectNotKnown,
01324 RTI::AttributeNotDefined,
01325 RTI::AttributeNotOwned,
01326 RTI::AttributeAlreadyBeingDivested,
01327 RTI::FederateNotExecutionMember,
01328 RTI::ConcurrentAccessAttempted,
01329 RTI::SaveInProgress,
01330 RTI::RestoreInProgress,
01331 RTI::RTIinternalError)
01332 {
01333 Message req, rep ;
01334
01335 req.type = Message::NEGOTIATED_ATTRIBUTE_OWNERSHIP_DIVESTITURE ;
01336 req.setObject(theObject);
01337 if (theTag == NULL)
01338 {
01339 throw RTI::RTIinternalError ("Calling negotiatedAttributeOwnershipDivestiture with Tag NULL") ;
01340 }
01341 req.setTag(theTag);
01342 req.setAHS(certi_cast<AttributeHandleSetImp>()(attrs).getAttributeHandles());
01343
01344 privateRefs->executeService(&req, &rep);
01345 }
01346
01347
01348
01349 void
01350 RTI::RTIambassador::
01351 attributeOwnershipAcquisition(ObjectHandle theObject,
01352 const AttributeHandleSet& desiredAttributes,
01353 const char *theTag)
01354 throw (RTI::ObjectNotKnown,
01355 RTI::ObjectClassNotPublished,
01356 RTI::AttributeNotDefined,
01357 RTI::AttributeNotPublished,
01358 RTI::FederateOwnsAttributes,
01359 RTI::FederateNotExecutionMember,
01360 RTI::ConcurrentAccessAttempted,
01361 RTI::SaveInProgress,
01362 RTI::RestoreInProgress,
01363 RTI::RTIinternalError)
01364 {
01365 Message req, rep ;
01366
01367 req.type = Message::ATTRIBUTE_OWNERSHIP_ACQUISITION ;
01368 req.setObject(theObject);
01369 if (theTag == NULL)
01370 {
01371 throw RTI::RTIinternalError ("Calling attributeOwnershipAcquisition with Tag NULL") ;
01372 }
01373 req.setTag(theTag);
01374 req.setAHS(certi_cast<AttributeHandleSetImp>()(desiredAttributes).getAttributeHandles());
01375
01376 privateRefs->executeService(&req, &rep);
01377 }
01378
01379
01380
01381 RTI::AttributeHandleSet*
01382 RTI::RTIambassador::
01383 attributeOwnershipReleaseResponse(ObjectHandle theObject,
01384 const AttributeHandleSet& attrs)
01385 throw (RTI::ObjectNotKnown,
01386 RTI::AttributeNotDefined,
01387 RTI::AttributeNotOwned,
01388 RTI::FederateWasNotAskedToReleaseAttribute,
01389 RTI::FederateNotExecutionMember,
01390 RTI::ConcurrentAccessAttempted,
01391 RTI::SaveInProgress,
01392 RTI::RestoreInProgress,
01393 RTI::RTIinternalError)
01394 {
01395 Message req, rep ;
01396
01397 req.type = Message::ATTRIBUTE_OWNERSHIP_RELEASE_RESPONSE ;
01398 req.setObject(theObject);
01399 req.setAHS(certi_cast<AttributeHandleSetImp>()(attrs).getAttributeHandles());
01400
01401 privateRefs->executeService(&req, &rep);
01402
01403 if (rep.getExceptionType() == e_NO_EXCEPTION) {
01404 return new AttributeHandleSetImp(rep.getAHS());
01405 }
01406
01407 return NULL ;
01408 }
01409
01410
01411
01412 void
01413 RTI::RTIambassador::
01414 cancelNegotiatedAttributeOwnershipDivestiture(ObjectHandle theObject,
01415 const AttributeHandleSet& attrs)
01416 throw (RTI::ObjectNotKnown,
01417 RTI::AttributeNotDefined,
01418 RTI::AttributeNotOwned,
01419 RTI::AttributeDivestitureWasNotRequested,
01420 RTI::FederateNotExecutionMember,
01421 RTI::ConcurrentAccessAttempted,
01422 RTI::SaveInProgress,
01423 RTI::RestoreInProgress,
01424 RTI::RTIinternalError)
01425 {
01426 Message req, rep ;
01427
01428 req.type = Message::CANCEL_NEGOTIATED_ATTRIBUTE_OWNERSHIP_DIVESTITURE ;
01429 req.setObject(theObject);
01430 req.setAHS(certi_cast<AttributeHandleSetImp>()(attrs).getAttributeHandles());
01431
01432 privateRefs->executeService(&req, &rep);
01433 }
01434
01435
01436
01437 void
01438 RTI::RTIambassador::
01439 cancelAttributeOwnershipAcquisition(ObjectHandle theObject,
01440 const AttributeHandleSet& attrs)
01441 throw (RTI::ObjectNotKnown,
01442 RTI::AttributeNotDefined,
01443 RTI::AttributeAlreadyOwned,
01444 RTI::AttributeAcquisitionWasNotRequested,
01445 RTI::FederateNotExecutionMember,
01446 RTI::ConcurrentAccessAttempted,
01447 RTI::SaveInProgress,
01448 RTI::RestoreInProgress,
01449 RTI::RTIinternalError)
01450 {
01451 Message req, rep ;
01452
01453 req.type = Message::CANCEL_ATTRIBUTE_OWNERSHIP_ACQUISITION ;
01454 req.setObject(theObject);
01455 req.setAHS(certi_cast<AttributeHandleSetImp>()(attrs).getAttributeHandles());
01456
01457 privateRefs->executeService(&req, &rep);
01458 }
01459
01460
01461
01462 void
01463 RTI::RTIambassador::
01464 attributeOwnershipAcquisitionIfAvailable(ObjectHandle theObject,
01465 const AttributeHandleSet& desired)
01466 throw (RTI::ObjectNotKnown,
01467 RTI::ObjectClassNotPublished,
01468 RTI::AttributeNotDefined,
01469 RTI::AttributeNotPublished,
01470 RTI::FederateOwnsAttributes,
01471 RTI::AttributeAlreadyBeingAcquired,
01472 RTI::FederateNotExecutionMember,
01473 RTI::ConcurrentAccessAttempted,
01474 RTI::SaveInProgress,
01475 RTI::RestoreInProgress,
01476 RTI::RTIinternalError)
01477 {
01478 Message req, rep ;
01479
01480 req.type = Message::ATTRIBUTE_OWNERSHIP_ACQUISITION_IF_AVAILABLE ;
01481 req.setObject(theObject);
01482 req.setAHS(certi_cast<AttributeHandleSetImp>()(desired).getAttributeHandles());
01483
01484 privateRefs->executeService(&req, &rep);
01485 }
01486
01487
01488
01489 void
01490 RTI::RTIambassador::
01491 queryAttributeOwnership(ObjectHandle theObject,
01492 AttributeHandle theAttribute)
01493 throw (RTI::RTIinternalError, RTI::RestoreInProgress,
01494 RTI::SaveInProgress, RTI::ConcurrentAccessAttempted,
01495 RTI::FederateNotExecutionMember, RTI::AttributeNotDefined,
01496 RTI::ObjectNotKnown)
01497 {
01498 Message req, rep ;
01499
01500 req.type = Message::QUERY_ATTRIBUTE_OWNERSHIP ;
01501 req.setObject(theObject);
01502 req.setAttribute(theAttribute);
01503
01504 privateRefs->executeService(&req, &rep);
01505 }
01506
01507
01508
01509 RTI::Boolean
01510 RTI::RTIambassador::isAttributeOwnedByFederate(ObjectHandle theObject,
01511 AttributeHandle theAttribute)
01512 throw (RTI::ObjectNotKnown,
01513 RTI::AttributeNotDefined,
01514 RTI::FederateNotExecutionMember,
01515 RTI::ConcurrentAccessAttempted,
01516 RTI::SaveInProgress,
01517 RTI::RestoreInProgress,
01518 RTI::RTIinternalError)
01519 {
01520 Message req, rep ;
01521
01522 req.type = Message::IS_ATTRIBUTE_OWNED_BY_FEDERATE ;
01523 req.setObject(theObject);
01524 req.setAttribute(theAttribute);
01525
01526 privateRefs->executeService(&req, &rep);
01527
01528 return ((strcmp((rep.getTag()).c_str(), "RTI_TRUE") == 0) ? RTI_TRUE : RTI_FALSE);
01529 }
01530
01531
01532
01533 void
01534 RTI::RTIambassador::enableTimeRegulation(const RTI::FedTime& theFederateTime,
01535 const RTI::FedTime& theLookahead)
01536 throw (RTI::RTIinternalError, RTI::RestoreInProgress,
01537 RTI::SaveInProgress, RTI::FederateNotExecutionMember,
01538 RTI::ConcurrentAccessAttempted, RTI::InvalidLookahead,
01539 RTI::InvalidFederationTime, RTI::TimeAdvanceAlreadyInProgress,
01540 RTI::EnableTimeRegulationPending, RTI::TimeRegulationAlreadyEnabled)
01541 {
01542 Message req, rep ;
01543 req.type = Message::ENABLE_TIME_REGULATION ;
01544 req.setFedTime(certi_cast<RTIfedTime>()(theFederateTime).getTime());
01545 req.setLookahead(certi_cast<RTIfedTime>()(theLookahead).getTime());
01546 req.setBoolean(true);
01547 privateRefs->executeService(&req, &rep);
01548 }
01549
01550
01551
01552 void
01553 RTI::RTIambassador::disableTimeRegulation()
01554 throw (RTI::RTIinternalError,
01555 RTI::RestoreInProgress, RTI::SaveInProgress,
01556 RTI::FederateNotExecutionMember, RTI::ConcurrentAccessAttempted,
01557 RTI::TimeRegulationWasNotEnabled)
01558 {
01559 Message req, rep ;
01560 req.type = Message::DISABLE_TIME_REGULATION ;
01561 req.setBoolean(false);
01562 privateRefs->executeService(&req, &rep);
01563 }
01564
01565
01566
01567 void
01568 RTI::RTIambassador::enableTimeConstrained()
01569 throw (RTI::TimeConstrainedAlreadyEnabled,
01570 RTI::EnableTimeConstrainedPending,
01571 RTI::TimeAdvanceAlreadyInProgress,
01572 RTI::FederateNotExecutionMember,
01573 RTI::ConcurrentAccessAttempted,
01574 RTI::SaveInProgress,
01575 RTI::RestoreInProgress,
01576 RTI::RTIinternalError)
01577 {
01578 Message req, rep ;
01579
01580 req.type = Message::ENABLE_TIME_CONSTRAINED ;
01581 req.setBoolean(true);
01582 privateRefs->executeService(&req, &rep);
01583 }
01584
01585
01586
01587 void
01588 RTI::RTIambassador::disableTimeConstrained()
01589 throw (RTI::TimeConstrainedWasNotEnabled,
01590 RTI::FederateNotExecutionMember,
01591 RTI::ConcurrentAccessAttempted,
01592 RTI::SaveInProgress,
01593 RTI::RestoreInProgress,
01594 RTI::RTIinternalError)
01595 {
01596 Message req, rep ;
01597
01598 req.type = Message::DISABLE_TIME_CONSTRAINED ;
01599 req.setBoolean(false);
01600 privateRefs->executeService(&req, &rep);
01601 }
01602
01603
01604
01605 void
01606 RTI::RTIambassador::timeAdvanceRequest(const RTI::FedTime& theTime)
01607 throw (RTI::TimeAdvanceAlreadyInProgress,
01608 RTI::FederationTimeAlreadyPassed,
01609 RTI::InvalidFederationTime,
01610 RTI::EnableTimeRegulationPending,
01611 RTI::EnableTimeConstrainedPending,
01612 RTI::FederateNotExecutionMember,
01613 RTI::ConcurrentAccessAttempted,
01614 RTI::SaveInProgress,
01615 RTI::RestoreInProgress,
01616 RTI::RTIinternalError)
01617 {
01618 Message req, rep ;
01619
01620 req.type = Message::TIME_ADVANCE_REQUEST ;
01621 req.setFedTime(certi_cast<RTIfedTime>()(theTime).getTime());
01622 privateRefs->executeService(&req, &rep);
01623 }
01624
01625
01626
01627 void
01628 RTI::RTIambassador::timeAdvanceRequestAvailable(const RTI::FedTime& theTime)
01629 throw (RTI::RTIinternalError, RTI::RestoreInProgress, RTI::SaveInProgress,
01630 RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember,
01631 RTI::EnableTimeConstrainedPending, RTI::EnableTimeRegulationPending,
01632 RTI::TimeAdvanceAlreadyInProgress, RTI::FederationTimeAlreadyPassed,
01633 RTI::InvalidFederationTime)
01634 {
01635 Message req, rep ;
01636
01637 req.type = Message::TIME_ADVANCE_REQUEST_AVAILABLE ;
01638 req.setFedTime(certi_cast<RTIfedTime>()(theTime).getTime());
01639
01640 privateRefs->executeService(&req, &rep);
01641 }
01642
01643
01644
01645 void
01646 RTI::RTIambassador::nextEventRequest(const RTI::FedTime& theTime)
01647 throw (RTI::TimeAdvanceAlreadyInProgress,
01648 RTI::FederationTimeAlreadyPassed,
01649 RTI::InvalidFederationTime,
01650 RTI::EnableTimeRegulationPending,
01651 RTI::EnableTimeConstrainedPending,
01652 RTI::FederateNotExecutionMember,
01653 RTI::ConcurrentAccessAttempted,
01654 RTI::SaveInProgress,
01655 RTI::RestoreInProgress,
01656 RTI::RTIinternalError)
01657 {
01658 Message req, rep ;
01659
01660 req.type = Message::NEXT_EVENT_REQUEST ;
01661 req.setFedTime(certi_cast<RTIfedTime>()(theTime).getTime());
01662 privateRefs->executeService(&req, &rep);
01663 }
01664
01665
01666
01667 void
01668 RTI::RTIambassador::nextEventRequestAvailable(const RTI::FedTime& theTime)
01669 throw (RTI::RTIinternalError, RTI::RestoreInProgress, RTI::SaveInProgress,
01670 RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember,
01671 RTI::EnableTimeConstrainedPending, RTI::EnableTimeRegulationPending,
01672 RTI::TimeAdvanceAlreadyInProgress, RTI::FederationTimeAlreadyPassed,
01673 RTI::InvalidFederationTime)
01674 {
01675 Message req, rep ;
01676
01677 req.type = Message::NEXT_EVENT_REQUEST_AVAILABLE ;
01678 req.setFedTime(certi_cast<RTIfedTime>()(theTime).getTime());
01679 privateRefs->executeService(&req, &rep);
01680 }
01681
01682
01683
01684 void
01685 RTI::RTIambassador::flushQueueRequest(const RTI::FedTime& theTime)
01686 throw (RTI::TimeAdvanceAlreadyInProgress,
01687 RTI::FederationTimeAlreadyPassed,
01688 RTI::InvalidFederationTime,
01689 RTI::EnableTimeRegulationPending,
01690 RTI::EnableTimeConstrainedPending,
01691 RTI::FederateNotExecutionMember,
01692 RTI::ConcurrentAccessAttempted,
01693 RTI::SaveInProgress,
01694 RTI::RestoreInProgress,
01695 RTI::RTIinternalError)
01696 {
01697 throw RTI::RTIinternalError("Unimplemented Service flushQueueRequest");
01698 Message req, rep ;
01699
01700 req.type = Message::FLUSH_QUEUE_REQUEST ;
01701 req.setFedTime(certi_cast<RTIfedTime>()(theTime).getTime());
01702
01703 privateRefs->executeService(&req, &rep);
01704 }
01705
01706
01707
01708 void
01709 RTI::RTIambassador::enableAsynchronousDelivery()
01710 throw (RTI::RTIinternalError, RTI::RestoreInProgress, RTI::SaveInProgress,
01711 RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember,
01712 RTI::AsynchronousDeliveryAlreadyEnabled)
01713 {
01714
01715
01716 Message req, rep ;
01717
01718 req.type = Message::ENABLE_ASYNCHRONOUS_DELIVERY ;
01719
01720 privateRefs->executeService(&req, &rep);
01721 }
01722
01723
01724
01725 void
01726 RTI::RTIambassador::disableAsynchronousDelivery()
01727 throw (RTI::RTIinternalError, RTI::RestoreInProgress, RTI::SaveInProgress,
01728 RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember,
01729 RTI::AsynchronousDeliveryAlreadyDisabled)
01730 {
01731 Message req, rep ;
01732
01733 req.type = Message::DISABLE_ASYNCHRONOUS_DELIVERY ;
01734
01735 privateRefs->executeService(&req, &rep);
01736 }
01737
01738
01739
01740 void
01741 RTI::RTIambassador::queryLBTS(RTI::FedTime& theTime)
01742 throw (RTI::FederateNotExecutionMember,
01743 RTI::ConcurrentAccessAttempted,
01744 RTI::SaveInProgress,
01745 RTI::RestoreInProgress,
01746 RTI::RTIinternalError)
01747 {
01748 Message req, rep ;
01749
01750 req.type = Message::QUERY_LBTS ;
01751 privateRefs->executeService(&req, &rep);
01752
01753 certi_cast<RTIfedTime>()(theTime) = rep.getFedTime();
01754 }
01755
01756
01757
01758 void
01759 RTI::RTIambassador::queryFederateTime(RTI::FedTime& theTime)
01760 throw (RTI::FederateNotExecutionMember,
01761 RTI::ConcurrentAccessAttempted,
01762 RTI::SaveInProgress,
01763 RTI::RestoreInProgress,
01764 RTI::RTIinternalError)
01765 {
01766 Message req, rep ;
01767
01768 req.type = Message::QUERY_FEDERATE_TIME ;
01769 privateRefs->executeService(&req, &rep);
01770
01771 certi_cast<RTIfedTime>()(theTime) = rep.getFedTime();
01772 }
01773
01774
01775
01776 void
01777 RTI::RTIambassador::queryMinNextEventTime(RTI::FedTime& theTime)
01778 throw (RTI::FederateNotExecutionMember,
01779 RTI::ConcurrentAccessAttempted,
01780 RTI::SaveInProgress,
01781 RTI::RestoreInProgress,
01782 RTI::RTIinternalError)
01783 {
01784 Message req, rep ;
01785
01786 req.type = Message::QUERY_MIN_NEXT_EVENT_TIME ;
01787 privateRefs->executeService(&req, &rep);
01788
01789 certi_cast<RTIfedTime>()(theTime) = rep.getFedTime();
01790 }
01791
01792
01793
01794 void
01795 RTI::RTIambassador::modifyLookahead(const RTI::FedTime& theLookahead)
01796 throw (RTI::RTIinternalError, RTI::RestoreInProgress, RTI::SaveInProgress,
01797 RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember,
01798 RTI::InvalidLookahead)
01799 {
01800 Message req, rep ;
01801
01802 req.type = Message::MODIFY_LOOKAHEAD ;
01803 req.setLookahead(certi_cast<RTIfedTime>()(theLookahead).getTime());
01804
01805 privateRefs->executeService(&req, &rep);
01806 }
01807
01808
01809
01810 void
01811 RTI::RTIambassador::queryLookahead(RTI::FedTime &theTime)
01812 throw (RTI::FederateNotExecutionMember,
01813 RTI::ConcurrentAccessAttempted,
01814 RTI::SaveInProgress,
01815 RTI::RestoreInProgress,
01816 RTI::RTIinternalError)
01817 {
01818 Message req, rep ;
01819
01820 req.type = Message::QUERY_LOOKAHEAD ;
01821 privateRefs->executeService(&req, &rep);
01822
01823 certi_cast<RTIfedTime>()(theTime) = rep.getFederationTimeDelta().getTime();
01824 }
01825
01826
01827
01828 void
01829 RTI::RTIambassador::retract(RTI::EventRetractionHandle handle)
01830 throw (RTI::RTIinternalError, RTI::RestoreInProgress, RTI::SaveInProgress,
01831 RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember,
01832 RTI::InvalidRetractionHandle)
01833 {
01834 throw RTI::RTIinternalError("Unimplemented Service retract");
01835 Message req, rep ;
01836
01837 req.type = Message::RETRACT ;
01838 req.setEventRetraction(handle);
01839
01840 privateRefs->executeService(&req, &rep);
01841 }
01842
01843
01844
01845 void
01846 RTI::RTIambassador::changeAttributeOrderType(ObjectHandle theObject,
01847 const AttributeHandleSet& attrs,
01848 OrderingHandle theType)
01849 throw (RTI::RTIinternalError,
01850 RTI::RestoreInProgress, RTI::SaveInProgress, RTI::ConcurrentAccessAttempted,
01851 RTI::FederateNotExecutionMember, RTI::InvalidOrderingHandle,
01852 RTI::AttributeNotOwned, RTI::AttributeNotDefined, RTI::ObjectNotKnown)
01853 {
01854 Message req, rep ;
01855
01856 req.type = Message::CHANGE_ATTRIBUTE_ORDER_TYPE ;
01857 req.setObject(theObject);
01858 req.setOrdering(theType);
01859 req.setAHS(certi_cast<AttributeHandleSetImp>()(attrs).getAttributeHandles());
01860
01861 privateRefs->executeService(&req, &rep);
01862 }
01863
01864
01865
01866 void
01867 RTI::RTIambassador::changeInteractionOrderType(InteractionClassHandle theClass,
01868 OrderingHandle theType)
01869 throw (RTI::RTIinternalError, RTI::RestoreInProgress,
01870 RTI::SaveInProgress, RTI::ConcurrentAccessAttempted,
01871 RTI::FederateNotExecutionMember, RTI::InvalidOrderingHandle,
01872 RTI::InteractionClassNotPublished, RTI::InteractionClassNotDefined)
01873 {
01874 Message req, rep ;
01875
01876 req.type = Message::CHANGE_INTERACTION_ORDER_TYPE ;
01877 req.setInteractionClass(theClass);
01878 req.setOrdering(theType);
01879
01880 privateRefs->executeService(&req, &rep);
01881 }
01882
01883
01889 RTI::Region *
01890 RTI::RTIambassador::createRegion(SpaceHandle space, ULong nb_extents)
01891 throw (RTI::SpaceNotDefined,
01892 RTI::InvalidExtents,
01893 RTI::FederateNotExecutionMember,
01894 RTI::ConcurrentAccessAttempted,
01895 RTI::SaveInProgress,
01896 RTI::RestoreInProgress,
01897 RTI::RTIinternalError)
01898 {
01899 Message req, rep ;
01900 req.setType(Message::DDM_CREATE_REGION);
01901 req.setSpace(space);
01902 req.setNumber(nb_extents);
01903 privateRefs->executeService(&req, &rep);
01904 RTI::Region *region = new RegionImp(rep.getRegion(), space,
01905 std::vector<Extent>(nb_extents,
01906 Extent(rep.getNumber())));
01907
01908 assert(region->getNumberOfExtents() == nb_extents);
01909 return region ;
01910 }
01911
01912
01917 void
01918 RTI::RTIambassador::notifyAboutRegionModification(Region &r)
01919 throw (RTI::RegionNotKnown,
01920 RTI::InvalidExtents,
01921 RTI::FederateNotExecutionMember,
01922 RTI::ConcurrentAccessAttempted,
01923 RTI::SaveInProgress,
01924 RTI::RestoreInProgress,
01925 RTI::RTIinternalError)
01926 {
01927 try {
01928 FedRegion ®ion = dynamic_cast<FedRegion &>(r);
01929 D[pdDebug] << "Notify About Region " << region.getHandle()
01930 << " Modification" << endl ;
01931 Message req, rep ;
01932
01933 req.setType(Message::DDM_MODIFY_REGION);
01934 req.setRegion(region.getHandle());
01935 req.setExtents(region.getExtents());
01936
01937 privateRefs->executeService(&req, &rep);
01938 region.commit();
01939 }
01940 catch (std::bad_cast) {
01941 throw RegionNotKnown("");
01942 }
01943 catch (Exception &e) {
01944 throw ;
01945 }
01946 }
01947
01948
01953 void
01954 RTI::RTIambassador::deleteRegion(Region *region)
01955 throw (RTI::RegionNotKnown,
01956 RTI::RegionInUse,
01957 RTI::FederateNotExecutionMember,
01958 RTI::ConcurrentAccessAttempted,
01959 RTI::SaveInProgress,
01960 RTI::RestoreInProgress,
01961 RTI::RTIinternalError)
01962 {
01963 if (region == 0) {
01964 throw RegionNotKnown("");
01965 }
01966
01967 Message req, rep ;
01968
01969 req.setType(Message::DDM_DELETE_REGION);
01970 try {
01971 req.setRegion(dynamic_cast<FedRegion *>(region)->getHandle());
01972 }
01973 catch (std::bad_cast) {
01974 throw RegionNotKnown("");
01975 }
01976 privateRefs->executeService(&req, &rep);
01977
01978 delete region ;
01979 }
01980
01981
01982
01983 ObjectHandle
01984 RTI::RTIambassador::registerObjectInstanceWithRegion(ObjectClassHandle object_class,
01985 const char *tag,
01986 AttributeHandle attrs[],
01987 Region *regions[],
01988 ULong nb)
01989 throw (RTI::ObjectClassNotDefined,
01990 RTI::ObjectClassNotPublished,
01991 RTI::AttributeNotDefined,
01992 RTI::AttributeNotPublished,
01993 RTI::RegionNotKnown,
01994 RTI::InvalidRegionContext,
01995 RTI::ObjectAlreadyRegistered,
01996 RTI::FederateNotExecutionMember,
01997 RTI::ConcurrentAccessAttempted,
01998 RTI::SaveInProgress,
01999 RTI::RestoreInProgress,
02000 RTI::RTIinternalError)
02001 {
02002 Message req, rep ;
02003
02004 req.setType(Message::DDM_REGISTER_OBJECT);
02005 req.setObjectClass(object_class);
02006 if ( tag != NULL )
02007 {
02008 req.setTag(tag);
02009 }
02010 req.setAHS(attrs, nb);
02011 req.setRegions(build_region_handles(regions, nb));
02012
02013 privateRefs->executeService(&req, &rep);
02014
02015 return rep.getObject();
02016 }
02017
02018
02019 ObjectHandle
02020 RTI::RTIambassador::registerObjectInstanceWithRegion(ObjectClassHandle object_class,
02021 AttributeHandle attrs[],
02022 Region *regions[],
02023 ULong nb)
02024 throw (RTI::ObjectClassNotDefined,
02025 RTI::ObjectClassNotPublished,
02026 RTI::AttributeNotDefined,
02027 RTI::AttributeNotPublished,
02028 RTI::RegionNotKnown,
02029 RTI::InvalidRegionContext,
02030 RTI::FederateNotExecutionMember,
02031 RTI::ConcurrentAccessAttempted,
02032 RTI::SaveInProgress,
02033 RTI::RestoreInProgress,
02034 RTI::RTIinternalError)
02035 {
02036 Message req, rep ;
02037
02038 req.setType(Message::DDM_REGISTER_OBJECT);
02039 req.setObjectClass(object_class);
02040 req.setAHS(attrs, nb);
02041 req.setRegions(build_region_handles(regions, nb));
02042
02043 privateRefs->executeService(&req, &rep);
02044
02045 return rep.getObject();
02046 }
02047
02048
02056 void
02057 RTI::RTIambassador::associateRegionForUpdates(Region ®ion,
02058 ObjectHandle object,
02059 const AttributeHandleSet &attributes)
02060 throw (RTI::ObjectNotKnown,
02061 RTI::AttributeNotDefined,
02062 RTI::InvalidRegionContext,
02063 RTI::RegionNotKnown,
02064 RTI::FederateNotExecutionMember,
02065 RTI::ConcurrentAccessAttempted,
02066 RTI::SaveInProgress,
02067 RTI::RestoreInProgress,
02068 RTI::RTIinternalError)
02069 {
02070 D[pdDebug] << "+ Associate Region for Updates" << endl ;
02071
02072 Message req, rep ;
02073
02074 req.type = Message::DDM_ASSOCIATE_REGION ;
02075 req.setObject(object);
02076 req.setRegion(get_handle(region));
02077 req.setAHS(certi_cast<AttributeHandleSetImp>()(attributes).getAttributeHandles());
02078
02079 privateRefs->executeService(&req, &rep);
02080 D[pdDebug] << "- Associate Region for Updates" << endl ;
02081 }
02082
02083
02090 void
02091 RTI::RTIambassador::unassociateRegionForUpdates(Region ®ion,
02092 ObjectHandle object)
02093 throw (RTI::ObjectNotKnown,
02094 RTI::InvalidRegionContext,
02095 RTI::RegionNotKnown,
02096 RTI::FederateNotExecutionMember,
02097 RTI::ConcurrentAccessAttempted,
02098 RTI::SaveInProgress,
02099 RTI::RestoreInProgress,
02100 RTI::RTIinternalError)
02101 {
02102 D[pdDebug] << "+ Unassociate Region for Updates" << endl ;
02103 Message req, rep ;
02104
02105 req.type = Message::DDM_UNASSOCIATE_REGION ;
02106 req.setObject(object);
02107 req.setRegion(get_handle(region));
02108
02109 privateRefs->executeService(&req, &rep);
02110 D[pdDebug] << "- Unassociate Region for Updates" << endl ;
02111 }
02112
02113
02121 void
02122 RTI::RTIambassador::subscribeObjectClassAttributesWithRegion(
02123 ObjectClassHandle object_class,
02124 Region ®ion,
02125 const AttributeHandleSet &attributes,
02126 Boolean passive)
02127 throw (RTI::ObjectClassNotDefined,
02128 RTI::AttributeNotDefined,
02129 RTI::RegionNotKnown,
02130 RTI::InvalidRegionContext,
02131 RTI::FederateNotExecutionMember,
02132 RTI::ConcurrentAccessAttempted,
02133 RTI::SaveInProgress,
02134 RTI::RestoreInProgress,
02135 RTI::RTIinternalError)
02136 {
02137 D[pdDebug] << "+ Subscribe Object Class Attributes with Region" << endl ;
02138 Message req, rep ;
02139
02140 req.type = Message::DDM_SUBSCRIBE_ATTRIBUTES ;
02141 req.setObjectClass(object_class);
02142 req.setRegion(get_handle(region));
02143 req.setAHS(certi_cast<AttributeHandleSetImp>()(attributes).getAttributeHandles());
02144 req.setBoolean(passive);
02145
02146 privateRefs->executeService(&req, &rep);
02147 D[pdDebug] << "- Subscribe Object Class Attributes with Region" << endl ;
02148 }
02149
02150
02156 void
02157 RTI::RTIambassador::unsubscribeObjectClassWithRegion(ObjectClassHandle object_class,
02158 Region ®ion)
02159 throw (RTI::ObjectClassNotDefined,
02160 RTI::RegionNotKnown,
02161 RTI::ObjectClassNotSubscribed,
02162 RTI::FederateNotExecutionMember,
02163 RTI::ConcurrentAccessAttempted,
02164 RTI::SaveInProgress,
02165 RTI::RestoreInProgress,
02166 RTI::RTIinternalError)
02167 {
02168 D[pdDebug] << "+ Unsubscribe Object Class " << object_class
02169 << " with Region" << endl ;
02170 Message req, rep ;
02171
02172 req.type = Message::DDM_UNSUBSCRIBE_ATTRIBUTES ;
02173 req.setObjectClass(object_class);
02174 req.setRegion(get_handle(region));
02175
02176 privateRefs->executeService(&req, &rep);
02177 D[pdDebug] << "- Unsubscribe Object Class with Region" << endl ;
02178 }
02179
02180
02181
02182 void
02183 RTI::RTIambassador::subscribeInteractionClassWithRegion(InteractionClassHandle ic,
02184 Region ®ion,
02185 RTI::Boolean passive)
02186 throw (RTI::InteractionClassNotDefined,
02187 RTI::RegionNotKnown,
02188 RTI::InvalidRegionContext,
02189 RTI::FederateLoggingServiceCalls,
02190 RTI::FederateNotExecutionMember,
02191 RTI::ConcurrentAccessAttempted,
02192 RTI::SaveInProgress,
02193 RTI::RestoreInProgress,
02194 RTI::RTIinternalError)
02195 {
02196 Message req, rep ;
02197
02198 req.type = Message::DDM_SUBSCRIBE_INTERACTION ;
02199 req.setInteractionClass(ic);
02200 req.setRegion(get_handle(region));
02201 req.setBoolean(passive);
02202
02203 privateRefs->executeService(&req, &rep);
02204 }
02205
02206
02207
02208 void
02209 RTI::RTIambassador::unsubscribeInteractionClassWithRegion(InteractionClassHandle ic,
02210 Region ®ion)
02211 throw (RTI::InteractionClassNotDefined,
02212 RTI::InteractionClassNotSubscribed,
02213 RTI::RegionNotKnown,
02214 RTI::FederateNotExecutionMember,
02215 RTI::ConcurrentAccessAttempted,
02216 RTI::SaveInProgress,
02217 RTI::RestoreInProgress,
02218 RTI::RTIinternalError)
02219 {
02220 Message req, rep ;
02221
02222 req.type = Message::DDM_UNSUBSCRIBE_INTERACTION ;
02223 req.setInteractionClass(ic);
02224 req.setRegion(get_handle(region));
02225
02226 privateRefs->executeService(&req, &rep);
02227 }
02228
02229
02230
02231 RTI::EventRetractionHandle
02232 RTI::RTIambassador::sendInteractionWithRegion(InteractionClassHandle interaction,
02233 const ParameterHandleValuePairSet &par,
02234 const RTI::FedTime &time,
02235 const char *tag,
02236 const Region ®ion)
02237 throw (RTI::InteractionClassNotDefined,
02238 RTI::InteractionClassNotPublished,
02239 RTI::InteractionParameterNotDefined,
02240 RTI::InvalidFederationTime,
02241 RTI::RegionNotKnown,
02242 RTI::InvalidRegionContext,
02243 RTI::FederateNotExecutionMember,
02244 RTI::ConcurrentAccessAttempted,
02245 RTI::SaveInProgress,
02246 RTI::RestoreInProgress,
02247 RTI::RTIinternalError)
02248 {
02249 Message req, rep ;
02250
02251 req.setType(Message::SEND_INTERACTION);
02252 req.setInteractionClass(interaction);
02253 req.setPHVPS(certi_cast<ParameterHandleValuePairSetImp>()(par).getParameterHandleValuePairs());
02254 req.setFedTime(certi_cast<RTIfedTime>()(time).getTime());
02255 if ( tag == NULL )
02256 {
02257 throw RTI::RTIinternalError ("Calling sendInteractionWithRegion with Tag NULL");
02258 }
02259 req.setTag(tag);
02260 req.setRegion(get_handle(region));
02261
02262 privateRefs->executeService(&req, &rep);
02263
02264 return rep.getEventRetraction();
02265 }
02266
02267
02268 void
02269 RTI::RTIambassador::sendInteractionWithRegion(InteractionClassHandle interaction,
02270 const ParameterHandleValuePairSet &par,
02271 const char *tag,
02272 const Region ®ion)
02273 throw (RTI::InteractionClassNotDefined,
02274 RTI::InteractionClassNotPublished,
02275 RTI::InteractionParameterNotDefined,
02276 RTI::RegionNotKnown,
02277 RTI::InvalidRegionContext,
02278 RTI::FederateNotExecutionMember,
02279 RTI::ConcurrentAccessAttempted,
02280 RTI::SaveInProgress,
02281 RTI::RestoreInProgress,
02282 RTI::RTIinternalError)
02283 {
02284 Message req, rep ;
02285
02286 req.setType(Message::SEND_INTERACTION);
02287 req.setInteractionClass(interaction);
02288 req.setPHVPS(certi_cast<ParameterHandleValuePairSetImp>()(par).getParameterHandleValuePairs());
02289 if ( tag == NULL )
02290 {
02291 throw RTI::RTIinternalError ("Calling sendInteractionWithRegion with Tag NULL");
02292 }
02293 req.setTag(tag);
02294 req.setRegion(get_handle(region));
02295
02296 privateRefs->executeService(&req, &rep);
02297 }
02298
02299
02300
02301 void RTI::RTIambassador::
02302 requestClassAttributeValueUpdateWithRegion(ObjectClassHandle ,
02303 const AttributeHandleSet &attrs,
02304 const Region ®ion)
02305 throw (RTI::RTIinternalError, RTI::RestoreInProgress, RTI::SaveInProgress,
02306 RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember,
02307 RTI::RegionNotKnown, RTI::AttributeNotDefined, RTI::ObjectClassNotDefined)
02308 {
02309 throw RTI::RTIinternalError("unimplemented service requestClassAttributeValueUpdateWithRegion");
02310
02311 Message req, rep ;
02312 req.setType(Message::DDM_REQUEST_UPDATE);
02313 req.setAHS(certi_cast<AttributeHandleSetImp>()(attrs).getAttributeHandles());
02314 req.setRegion(get_handle(region));
02315 privateRefs->executeService(&req, &rep);
02316 }
02317
02318
02322 ObjectClassHandle
02323 RTI::RTIambassador::getObjectClassHandle(const char *theName)
02324 throw (RTI::NameNotFound,
02325 RTI::FederateNotExecutionMember,
02326 RTI::ConcurrentAccessAttempted,
02327 RTI::RTIinternalError)
02328 {
02329 Message req, rep ;
02330
02331 G.Out(pdGendoc,"enter RTIambassador::getObjectClassHandle");
02332
02333 req.type = Message::GET_OBJECT_CLASS_HANDLE ;
02334 req.setName(theName);
02335 privateRefs->executeService(&req, &rep);
02336
02337 G.Out(pdGendoc,"exit RTIambassador::getObjectClassHandle");
02338
02339 return rep.getObjectClass();
02340 }
02341
02342
02348 char *
02349 RTI::RTIambassador::getObjectClassName(ObjectClassHandle handle)
02350 throw (RTI::ObjectClassNotDefined,
02351 RTI::FederateNotExecutionMember,
02352 RTI::ConcurrentAccessAttempted,
02353 RTI::RTIinternalError)
02354 {
02355 Message req, rep ;
02356 req.type = Message::GET_OBJECT_CLASS_NAME ;
02357 req.setObjectClass(handle);
02358 privateRefs->executeService(&req, &rep);
02359 return hla_strdup(rep.getName());
02360 }
02361
02362
02367 AttributeHandle
02368 RTI::RTIambassador::getAttributeHandle(const char *theName,
02369 ObjectClassHandle whichClass)
02370 throw (RTI::ObjectClassNotDefined,
02371 RTI::NameNotFound,
02372 RTI::FederateNotExecutionMember,
02373 RTI::ConcurrentAccessAttempted,
02374 RTI::RTIinternalError)
02375 {
02376 G.Out(pdGendoc,"enter RTI::RTIambassador::getAttributeHandle");
02377 Message req, rep ;
02378 req.type = Message::GET_ATTRIBUTE_HANDLE ;
02379 req.setName(theName);
02380 req.setObjectClass(whichClass);
02381 privateRefs->executeService(&req, &rep);
02382 G.Out(pdGendoc,"exit RTI::RTIambassador::getAttributeHandle");
02383 return rep.getAttribute();
02384 }
02385
02386
02392 char *
02393 RTI::RTIambassador::getAttributeName(AttributeHandle theHandle,
02394 ObjectClassHandle whichClass)
02395 throw (RTI::ObjectClassNotDefined,
02396 RTI::AttributeNotDefined,
02397 RTI::FederateNotExecutionMember,
02398 RTI::ConcurrentAccessAttempted,
02399 RTI::RTIinternalError)
02400 {
02401 Message req, rep ;
02402 req.type = Message::GET_ATTRIBUTE_NAME ;
02403 req.setAttribute(theHandle);
02404 req.setObjectClass(whichClass);
02405 privateRefs->executeService(&req, &rep);
02406 return hla_strdup(rep.getName());
02407 }
02408
02409
02410
02411 InteractionClassHandle
02412 RTI::RTIambassador::getInteractionClassHandle(const char *theName)
02413 throw (RTI::NameNotFound,
02414 RTI::FederateNotExecutionMember,
02415 RTI::ConcurrentAccessAttempted,
02416 RTI::RTIinternalError)
02417 {
02418 Message req, rep ;
02419
02420 req.type = Message::GET_INTERACTION_CLASS_HANDLE ;
02421 req.setName(theName);
02422
02423 privateRefs->executeService(&req, &rep);
02424
02425 return rep.getInteractionClass();
02426 }
02427
02428
02429
02430 char *
02431 RTI::RTIambassador::getInteractionClassName(InteractionClassHandle theHandle)
02432 throw (RTI::InteractionClassNotDefined,
02433 RTI::FederateNotExecutionMember,
02434 RTI::ConcurrentAccessAttempted,
02435 RTI::RTIinternalError)
02436 {
02437 Message req, rep ;
02438
02439 req.type = Message::GET_INTERACTION_CLASS_NAME ;
02440 req.setInteractionClass(theHandle);
02441
02442 privateRefs->executeService(&req, &rep);
02443
02444 return hla_strdup(rep.getName());
02445 }
02446
02447
02448
02449 ParameterHandle
02450 RTI::RTIambassador::getParameterHandle(const char *theName,
02451 InteractionClassHandle whichClass)
02452 throw (RTI::InteractionClassNotDefined,
02453 RTI::NameNotFound,
02454 RTI::FederateNotExecutionMember,
02455 RTI::ConcurrentAccessAttempted,
02456 RTI::RTIinternalError)
02457 {
02458 Message req, rep ;
02459
02460 req.type = Message::GET_PARAMETER_HANDLE ;
02461 req.setName(theName);
02462 req.setInteractionClass(whichClass);
02463
02464 privateRefs->executeService(&req, &rep);
02465
02466 return rep.getParameter();
02467 }
02468
02469
02470
02471 char *
02472 RTI::RTIambassador::getParameterName(ParameterHandle theHandle,
02473 InteractionClassHandle whichClass)
02474 throw (RTI::InteractionClassNotDefined,
02475 RTI::InteractionParameterNotDefined,
02476 RTI::FederateNotExecutionMember,
02477 RTI::ConcurrentAccessAttempted,
02478 RTI::RTIinternalError)
02479 {
02480 Message req, rep ;
02481
02482 req.type = Message::GET_PARAMETER_NAME ;
02483 req.setParameter(theHandle);
02484 req.setInteractionClass(whichClass);
02485
02486 privateRefs->executeService(&req, &rep);
02487
02488 return hla_strdup(rep.getName());
02489 }
02490
02491
02492
02493 ObjectHandle
02494 RTI::RTIambassador::getObjectInstanceHandle(const char *theName)
02495 throw (RTI::RTIinternalError, RTI::ConcurrentAccessAttempted,
02496 RTI::FederateNotExecutionMember, RTI::ObjectNotKnown)
02497 {
02498 Message req, rep ;
02499
02500 req.type = Message::GET_OBJECT_INSTANCE_HANDLE ;
02501 req.setName(theName);
02502
02503 privateRefs->executeService(&req, &rep);
02504
02505 return rep.getObject();
02506 }
02507
02508
02509
02510 char *
02511 RTI::RTIambassador::getObjectInstanceName(ObjectHandle theHandle)
02512 throw (RTI::RTIinternalError, RTI::ConcurrentAccessAttempted,
02513 RTI::FederateNotExecutionMember, RTI::ObjectNotKnown)
02514 {
02515 Message req, rep ;
02516
02517 req.type = Message::GET_OBJECT_INSTANCE_NAME ;
02518 req.setObject(theHandle);
02519
02520 privateRefs->executeService(&req, &rep);
02521
02522 return hla_strdup(rep.getName());
02523 }
02524
02525
02529 SpaceHandle
02530 RTI::RTIambassador::getRoutingSpaceHandle(const char *rs_name)
02531 throw (RTI::NameNotFound,
02532 RTI::FederateNotExecutionMember,
02533 RTI::ConcurrentAccessAttempted,
02534 RTI::RTIinternalError)
02535 {
02536 D[pdDebug] << "Get routing space handle: " << rs_name << endl ;
02537 Message req, rep ;
02538 req.type = Message::GET_SPACE_HANDLE ;
02539 req.setName(rs_name);
02540 privateRefs->executeService(&req, &rep);
02541 return rep.getSpace();
02542 }
02543
02544
02548 char *
02549 RTI::RTIambassador::getRoutingSpaceName(SpaceHandle handle)
02550 throw (RTI::SpaceNotDefined,
02551 RTI::FederateNotExecutionMember,
02552 RTI::ConcurrentAccessAttempted,
02553 RTI::RTIinternalError)
02554 {
02555 Message req, rep ;
02556 req.type = Message::GET_SPACE_NAME ;
02557 req.setSpace(handle);
02558 privateRefs->executeService(&req, &rep);
02559 return hla_strdup(rep.getName());
02560 }
02561
02562
02567 DimensionHandle
02568 RTI::RTIambassador::getDimensionHandle(const char *dimension,
02569 SpaceHandle space)
02570 throw (RTI::SpaceNotDefined,
02571 RTI::NameNotFound,
02572 RTI::FederateNotExecutionMember,
02573 RTI::ConcurrentAccessAttempted,
02574 RTI::RTIinternalError)
02575 {
02576 Message req, rep ;
02577 req.type = Message::GET_DIMENSION_HANDLE ;
02578 req.setName(dimension);
02579 req.setSpace(space);
02580 privateRefs->executeService(&req, &rep);
02581 return rep.getDimension();
02582 }
02583
02584
02589 char *
02590 RTI::RTIambassador::getDimensionName(DimensionHandle dimension,
02591 SpaceHandle space)
02592 throw (RTI::SpaceNotDefined,
02593 RTI::DimensionNotDefined,
02594 RTI::FederateNotExecutionMember,
02595 RTI::ConcurrentAccessAttempted,
02596 RTI::RTIinternalError)
02597 {
02598 Message req, rep ;
02599 req.type = Message::GET_DIMENSION_NAME ;
02600 req.setDimension(dimension);
02601 req.setSpace(space);
02602 privateRefs->executeService(&req, &rep);
02603 return hla_strdup(rep.getName());
02604 }
02605
02606
02612 SpaceHandle
02613 RTI::RTIambassador::getAttributeRoutingSpaceHandle(AttributeHandle attribute,
02614 ObjectClassHandle object_class)
02615 throw (RTI::ObjectClassNotDefined,
02616 RTI::AttributeNotDefined,
02617 RTI::FederateNotExecutionMember,
02618 RTI::ConcurrentAccessAttempted,
02619 RTI::RTIinternalError)
02620 {
02621 Message req, rep ;
02622 req.type = Message::GET_ATTRIBUTE_SPACE_HANDLE ;
02623 req.setAttribute(attribute);
02624 req.setObjectClass(object_class);
02625 privateRefs->executeService(&req, &rep);
02626 return rep.getSpace();
02627 }
02628
02629
02630
02631 ObjectClassHandle
02632 RTI::RTIambassador::getObjectClass(ObjectHandle theObject)
02633 throw (RTI::RTIinternalError, RTI::ConcurrentAccessAttempted,
02634 RTI::FederateNotExecutionMember, RTI::ObjectNotKnown)
02635 {
02636 Message req, rep ;
02637 req.type = Message::GET_OBJECT_CLASS ;
02638 req.setObject(theObject);
02639 privateRefs->executeService(&req, &rep);
02640 return rep.getObjectClass();
02641 }
02642
02643
02648 SpaceHandle
02649 RTI::RTIambassador::getInteractionRoutingSpaceHandle(InteractionClassHandle inter)
02650 throw (RTI::InteractionClassNotDefined,
02651 RTI::FederateNotExecutionMember,
02652 RTI::ConcurrentAccessAttempted,
02653 RTI::RTIinternalError)
02654 {
02655 Message req, rep ;
02656 req.type = Message::GET_INTERACTION_SPACE_HANDLE ;
02657 req.setInteractionClass(inter);
02658 this->privateRefs->executeService(&req, &rep);
02659 return rep.getSpace();
02660 }
02661
02662
02663
02664 RTI::TransportationHandle
02665 RTI::RTIambassador::getTransportationHandle(const char *theName)
02666 throw (RTI::RTIinternalError, RTI::ConcurrentAccessAttempted,
02667 RTI::FederateNotExecutionMember, RTI::NameNotFound)
02668 {
02669 Message req, rep ;
02670 req.type = Message::GET_TRANSPORTATION_HANDLE ;
02671 req.setName(theName);
02672 privateRefs->executeService(&req, &rep);
02673 return rep.getTransportation();
02674 }
02675
02676
02677
02678 char *
02679 RTI::RTIambassador::getTransportationName(TransportationHandle theHandle)
02680 throw (RTI::RTIinternalError, RTI::ConcurrentAccessAttempted,
02681 RTI::FederateNotExecutionMember, RTI::InvalidTransportationHandle)
02682 {
02683 Message req, rep ;
02684 req.type = Message::GET_TRANSPORTATION_NAME ;
02685 req.setTransportation(theHandle);
02686 privateRefs->executeService(&req, &rep);
02687 return hla_strdup(rep.getName());
02688 }
02689
02690
02691
02692 RTI::OrderingHandle
02693 RTI::RTIambassador::getOrderingHandle(const char *theName)
02694 throw (RTI::RTIinternalError, RTI::ConcurrentAccessAttempted,
02695 RTI::FederateNotExecutionMember, RTI::NameNotFound)
02696 {
02697 Message req, rep ;
02698 req.type = Message::GET_ORDERING_HANDLE ;
02699 req.setName(theName);
02700 privateRefs->executeService(&req, &rep);
02701 return rep.getOrdering();
02702 }
02703
02704
02705
02706
02707 char *
02708 RTI::RTIambassador::getOrderingName(OrderingHandle theHandle)
02709 throw (RTI::RTIinternalError, RTI::ConcurrentAccessAttempted,
02710 RTI::FederateNotExecutionMember, RTI::InvalidOrderingHandle)
02711 {
02712 Message req, rep ;
02713 req.type = Message::GET_ORDERING_NAME ;
02714 req.setOrdering(theHandle);
02715 privateRefs->executeService(&req, &rep);
02716 return hla_strdup(rep.getName());
02717 }
02718
02737 void
02738 RTI::RTIambassador::enableClassRelevanceAdvisorySwitch()
02739 throw (RTI::RTIinternalError, RTI::RestoreInProgress, RTI::SaveInProgress,
02740 RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember)
02741 {
02742 Message req, rep ;
02743
02744 req.type = Message::ENABLE_CLASS_RELEVANCE_ADVISORY_SWITCH ;
02745 privateRefs->executeService(&req, &rep);
02746 }
02747
02766 void
02767 RTI::RTIambassador::disableClassRelevanceAdvisorySwitch()
02768 throw (RTI::RTIinternalError, RTI::RestoreInProgress, RTI::SaveInProgress,
02769 RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember)
02770 {
02771 Message req, rep ;
02772
02773 req.type = Message::DISABLE_CLASS_RELEVANCE_ADVISORY_SWITCH ;
02774 privateRefs->executeService(&req, &rep);
02775 }
02776
02796 void
02797 RTI::RTIambassador::enableAttributeRelevanceAdvisorySwitch()
02798 throw (RTI::RTIinternalError, RTI::RestoreInProgress, RTI::SaveInProgress,
02799 RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember)
02800 {
02801 Message req, rep ;
02802
02803 req.type = Message::ENABLE_ATTRIBUTE_RELEVANCE_ADVISORY_SWITCH ;
02804 privateRefs->executeService(&req, &rep);
02805 }
02806
02826 void
02827 RTI::RTIambassador::disableAttributeRelevanceAdvisorySwitch()
02828 throw (RTI::RTIinternalError, RTI::RestoreInProgress, RTI::SaveInProgress,
02829 RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember)
02830 {
02831 Message req, rep ;
02832
02833 req.type = Message::DISABLE_ATTRIBUTE_RELEVANCE_ADVISORY_SWITCH ;
02834 privateRefs->executeService(&req, &rep);
02835 }
02836
02855 void RTI::RTIambassador::enableAttributeScopeAdvisorySwitch()
02856 throw (RTI::RTIinternalError, RTI::RestoreInProgress, RTI::SaveInProgress,
02857 RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember)
02858 {
02859 Message req, rep ;
02860
02861 req.type = Message::ENABLE_ATTRIBUTE_SCOPE_ADVISORY_SWITCH ;
02862 privateRefs->executeService(&req, &rep);
02863 }
02864
02883 void
02884 RTI::RTIambassador::disableAttributeScopeAdvisorySwitch()
02885 throw (RTI::RTIinternalError, RTI::RestoreInProgress, RTI::SaveInProgress,
02886 RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember)
02887 {
02888 Message req, rep ;
02889
02890 req.type = Message::DISABLE_ATTRIBUTE_SCOPE_ADVISORY_SWITCH ;
02891 privateRefs->executeService(&req, &rep);
02892 }
02893
02912 void
02913 RTI::RTIambassador::enableInteractionRelevanceAdvisorySwitch()
02914 throw (RTI::RTIinternalError, RTI::RestoreInProgress, RTI::SaveInProgress,
02915 RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember)
02916 {
02917 Message req, rep ;
02918
02919 req.type = Message::ENABLE_INTERACTION_RELEVANCE_ADVISORY_SWITCH ;
02920 privateRefs->executeService(&req, &rep);
02921 }
02922
02941 void
02942 RTI::RTIambassador::disableInteractionRelevanceAdvisorySwitch()
02943 throw (RTI::RTIinternalError, RTI::RestoreInProgress, RTI::SaveInProgress,
02944 RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember)
02945 {
02946 Message req, rep ;
02947
02948 req.type = Message::DISABLE_INTERACTION_RELEVANCE_ADVISORY_SWITCH ;
02949 privateRefs->executeService(&req, &rep);
02950 }
02951
02952