00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #include <config.h>
00025 #include "RTIG.hh"
00026 #include "NM_Classes.hh"
00027
00028 #include <iostream>
00029 #include <cassert>
00030 #include <memory>
00031
00032 using std::endl ;
00033 using std::cout ;
00034
00035 namespace certi {
00036 namespace rtig {
00037
00038 static PrettyDebug D("RTIG", __FILE__);
00039 static PrettyDebug G("GENDOC",__FILE__);
00040
00041
00043 void
00044 RTIG::processCreateFederation(Socket *link, NetworkMessage *req)
00045 {
00046 std::string federation = req->federationName;
00047 std::string FEDid = req->FEDid;
00048 NM_Create_Federation_Execution rep;
00049
00050 G.Out(pdGendoc,"enter RTIG::processCreateFederation");
00051 G.Out(pdGendoc,"BEGIN ** CREATE FEDERATION SERVICE **");
00052
00053 if (federation.length() == 0)
00054 {
00055 G.Out(pdGendoc,"exit RTIG::processCreateFederation on exception RTIinternalError");
00056 throw RTIinternalError("Invalid Federation Name.");
00057 }
00058
00059 auditServer << "Federation Name : " << federation.c_str() ;
00060 Handle h = federationHandles.provide();
00061
00062 #ifdef FEDERATION_USES_MULTICAST
00063
00064 unsigned long base_adr_mc = inet_addr(ADRESSE_MULTICAST);
00065 SocketMC *com_mc = NULL ;
00066
00067
00068 com_mc = new SocketMC();
00069 if (com_mc == NULL) {
00070 D.Out(pdExcept, "Unable to allocate Multicast socket.");
00071 G.Out(pdGendoc,"exit RTIG::processCreateFederation on exception RTIinternalError")
00072 throw RTIinternalError("Unable to allocate Multicast socket.");
00073 }
00074
00075 com_mc->CreerSocketMC(base_adr_mc + h, MC_PORT);
00076
00077
00078 federations->createFederation(federation, h, com_mc);
00079
00080
00081 ClientSockets.push_front(com_mc);
00082
00083 #else
00084
00085
00086 try {
00087 federations.createFederation(federation.c_str(), h, FEDid.c_str());
00088 }
00089 catch (CouldNotOpenFED e)
00090 {
00091 rep.exception = e_CouldNotOpenFED ;
00092 rep.exceptionReason=e._reason;
00093 }
00094 catch (ErrorReadingFED e)
00095 {
00096 rep.exception = e_ErrorReadingFED ;
00097 rep.exceptionReason = e._reason ;
00098 }
00099 catch (FederationExecutionAlreadyExists e)
00100 {
00101 rep.exception = e_FederationExecutionAlreadyExists ;
00102 rep.exceptionReason =e._reason ;
00103 }
00104 #endif
00105
00106 if ( rep.exception == e_NO_EXCEPTION )
00107 {
00108 rep.federation = h ;
00109 rep.FEDid = FEDid;
00110 rep.federationName = federation;
00111 auditServer <<" created.";
00112
00113 }
00114
00115 G.Out(pdGendoc,"processCreateFederation===>write answer to RTIA");
00116
00117 rep.send(link,NM_msgBufSend);
00118
00119 D.Out(pdInit, "Federation \"%s\" created with Handle %d.",
00120 federation.c_str(), rep.federation);
00121
00122 G.Out(pdGendoc,"END ** CREATE FEDERATION SERVICE **");
00123 G.Out(pdGendoc,"exit RTIG::processCreateFederation");
00124 }
00125
00126
00128 void
00129 RTIG::processJoinFederation(Socket *link, NetworkMessage *req)
00130 {
00131 std::string federation = req->federationName ;
00132 std::string federate = req->federateName ;
00133 std::string filename ;
00134
00135 unsigned int peer = req->bestEffortPeer ;
00136 unsigned long address = req->bestEffortAddress ;
00137
00138 Handle num_federation ;
00139 FederateHandle num_federe ;
00140
00141 int nb_regulateurs ;
00142 int nb_federes ;
00143 bool pause ;
00144
00145 G.Out(pdGendoc,"BEGIN ** JOIN FEDERATION SERVICE **");
00146 G.Out(pdGendoc,"enter RTIG::processJoinFederation");
00147
00148 if ((federation.length()==0) || (federate.length() == 0))
00149 throw RTIinternalError("Invalid Federation/Federate Name.");
00150
00151 auditServer << "Federate \"" << federate.c_str() << "\" joins Federation \""
00152 << federation.c_str() << "\"" ;
00153
00154 federations.exists(federation.c_str(), num_federation);
00155
00156 try
00157 {
00158 num_federe = federations.addFederate(num_federation,
00159 federate.c_str(),
00160 static_cast<SocketTCP*>(link));
00161 }
00162 catch (FederateAlreadyExecutionMember &e)
00163 {
00164
00165
00166
00167
00168 NM_Get_FED_File repFED ;
00169 repFED.exception = e_FederateAlreadyExecutionMember ;
00170 repFED.exceptionReason="Federate with same name has yet joined the federation";
00171 G.Out(pdGendoc,"processJoinFederation==>Answer to RTIA GFF ERROR %s",repFED.exceptionReason.c_str());
00172 repFED.send(link,NM_msgBufSend);
00173
00174 G.Out(pdGendoc,"exit RTIG::processJoinFederation on Error");
00175 G.Out(pdGendoc,"END ** JOIN FEDERATION (BAD) SERVICE **");
00176
00177
00178 NM_Join_Federation_Execution rep ;
00179 rep.exception = e_FederateAlreadyExecutionMember ;
00180 rep.exceptionReason = "Federate with same name has yet joined the federation";
00181
00182 G.Out(pdGendoc,"processJoinFederation==>Answer to RTIA JFE ERROR %s",rep.exceptionReason.c_str());
00183
00184 rep.send(link,NM_msgBufSend);
00185 return ;
00186 }
00187
00188 #ifdef FEDERATION_USES_MULTICAST
00189 SocketMC *com_mc = NULL ;
00190
00191 federations.info(num_federation, nb_federes, nb_regulateurs,
00192 pause, com_mc);
00193 assert(com_mc != NULL);
00194 #else
00195 filename = federations.info(num_federation, nb_federes, nb_regulateurs, pause);
00196 #endif
00197
00198
00199 socketServer.setReferences(link->returnSocket(),
00200 num_federation,
00201 num_federe,
00202 address,
00203 peer);
00204
00205 auditServer << "(" << num_federation << ")with handle " << num_federe
00206 << ". Socket " << link->returnSocket();
00207
00208
00209
00210 NM_Join_Federation_Execution rep ;
00211 rep.federationName = federation;
00212 rep.federate = num_federe ;
00213 rep.federation = num_federation ;
00214 rep.numberOfRegulators = nb_regulateurs ;
00215 rep.bestEffortPeer = peer ;
00216 rep.bestEffortAddress = address ;
00217
00218
00219 TypeException e = e_NO_EXCEPTION ;
00220
00221 std::ifstream fedFile(filename.c_str());
00222 if ( !fedFile.is_open()) {
00223
00224
00225 cout << "processJoinFederation : FED file " << filename << " has vanished." << endl;
00226 e = e_RTIinternalError ;
00227 }
00228
00229
00230 NM_Get_FED_File repFED ;
00231 repFED.federate = num_federe ;
00232 repFED.federation = num_federation ;
00233 repFED.number = 0 ;
00234 repFED.FEDid = filename ;
00235 repFED.exception = e ;
00236
00237 D.Out(pdTrace,"send NetworkMessage of Type %d after open \"%s\"",
00238 repFED.getType(),repFED.FEDid.c_str());
00239 G.Out(pdGendoc,"processJoinFederation====>Begin FED file transfer");
00240
00241 repFED.send(link,NM_msgBufSend);
00242
00243 if ( e == e_NO_EXCEPTION )
00244 {
00245
00246 NM_Get_FED_File msg ;
00247 D.Out(pdTrace,"wait NetworkMessage of Type %d",msg.getType());
00248 msg.receive(link,NM_msgBufReceive);
00249 assert ( msg.number == 0 );
00250
00251
00252 std::string fileLine;
00253 int num_line = 0 ;
00254 while (!fedFile.eof())
00255 {
00256 num_line++;
00257
00258 std::getline(fedFile,fileLine);
00259 fileLine = fileLine+"\n";
00260
00261 repFED.exception = e_NO_EXCEPTION ;
00262 repFED.federate = num_federe ;
00263 repFED.federation = num_federation ;
00264 repFED.number = num_line ;
00265 repFED.FEDid = filename;
00266
00267 repFED.setFEDLine(fileLine);
00268
00269 repFED.send(link,NM_msgBufSend);
00270
00271
00272 msg.receive(link,NM_msgBufReceive);
00273 assert ( msg.number == num_line );
00274 }
00275
00276
00277 fedFile.close();
00278 repFED.exception = e_NO_EXCEPTION ;
00279 repFED.federate = num_federe ;
00280 repFED.federation = num_federation ;
00281 repFED.number = 0 ;
00282 repFED.FEDid = filename;
00283
00284
00285 G.Out(pdGendoc,"processJoinFederation====>End FED file transfer");
00286
00287 repFED.send(link,NM_msgBufSend);
00288 }
00289
00290
00291
00292
00293 #ifdef FEDERATION_USES_MULTICAST
00294 rep.AdresseMulticast = com_mc->returnAdress();
00295 #endif
00296
00297 D.Out(pdInit, "Federate \"%s\" has joined Federation %u under handle %u.",
00298 federate.c_str(), num_federation, num_federe);
00299
00300
00301
00302 rep.send(link,NM_msgBufSend);
00303
00304 G.Out(pdGendoc,"exit RTIG::processJoinFederation");
00305 G.Out(pdGendoc,"END ** JOIN FEDERATION SERVICE **");
00306
00307 }
00308
00309
00311 void
00312 RTIG::processResignFederation(Socket *link,Handle federation,
00313 FederateHandle federe)
00314 {
00315 NM_Resign_Federation_Execution reponse ;
00316
00317 G.Out(pdGendoc,"BEGIN ** RESIGN FEDERATION SERVICE **");
00318 G.Out(pdGendoc,"enter RTIG::processResignFederation");
00319
00320 federations.remove(federation, federe);
00321 D.Out(pdInit, "Federate %u is resigning from federation %u.",
00322 federe, federation);
00323
00324 auditServer << "Federate " << federe << " resign federation("<<federation<<")" ;
00325
00326
00327 reponse.federate = federe ;
00328 reponse.federation = federation ;
00329 reponse.send(link,NM_msgBufSend);
00330
00331 G.Out(pdGendoc,"exit RTIG::processResignFederation");
00332 G.Out(pdGendoc,"END ** RESIGN FEDERATION SERVICE **");
00333
00334 }
00335
00336
00338 void
00339 RTIG::processDestroyFederation(Socket *link, NetworkMessage *req)
00340 {
00341 NM_Destroy_Federation_Execution rep ;
00342 Handle num_federation ;
00343
00344 std::string federation = req->federationName ;
00345
00346 G.Out(pdGendoc,"enter RTIG::processDestroyFederation");
00347 G.Out(pdGendoc,"BEGIN ** DESTROY FEDERATION SERVICE **");
00348
00349 if (federation.length() == 0) throw RTIinternalError("Invalid Federation Name.");
00350
00351 federations.exists(federation.c_str(), num_federation);
00352
00353
00354
00355 try {
00356 federations.destroyFederation(num_federation);
00357
00358 federationHandles.free(num_federation);
00359 D.Out(pdInit, "Federation \"%s\" has been destroyed.", federation.c_str());
00360 }
00361 catch (Exception &e)
00362 { printf("ERROR : %s reason : %s\n",e._name,e._reason.c_str());
00363 if (strcmp(e._name,"RTIinternalError")==0 )
00364 {
00365 rep.exception = e_RTIinternalError;
00366 rep.exceptionReason = e._reason;
00367 }
00368 else if (strcmp(e._name,"FederationExecutionDoesNotExist")==0 )
00369 {
00370 rep.exception = e_FederationExecutionDoesNotExist;
00371 rep.exceptionReason =e._reason;
00372 }
00373 else if (strcmp(e._name,"FederatesCurrentlyJoined")==0 )
00374 {
00375 rep.exception = e_FederatesCurrentlyJoined;
00376 rep.exceptionReason = "at least one federate joined";
00377 }
00378 }
00379
00380 rep.federate = req->federate ;
00381 rep.federationName = req->federationName;
00382 if ( rep.exception == e_NO_EXCEPTION )
00383 {
00384 auditServer << "Federation Name \"" << federation.c_str() << "\"("<<num_federation<<") destroyed." ;
00385 }
00386 G.Out(pdGendoc,"processDestroyFederation===>write DFE to RTIA");
00387
00388 rep.send(link,NM_msgBufSend);
00389
00390 G.Out(pdGendoc,"END ** DESTROY FEDERATION SERVICE **");
00391 G.Out(pdGendoc,"exit RTIG::processDestroyFederation");
00392 }
00393
00394
00396 void
00397 RTIG::processSetClassRelevanceAdvisorySwitch(Socket *link,
00398 NM_Set_Class_Relevance_Advisory_Switch *msg)
00399 {
00400 NM_Set_Class_Relevance_Advisory_Switch rep;
00401
00402 G.Out(pdGendoc,"enter RTIG::processSetClassRelevanceAdvisorySwitch");
00403 G.Out(pdGendoc,"BEGIN ** SET CLASS RELEVANCE ADVISORY SWITCH **");
00404
00405 if (msg->getClassRelevanceAdvisorySwitch()) {
00406 auditServer << "ON";
00407 federations.setClassRelevanceAdvisorySwitch(msg->federation, msg->federate);
00408 D.Out(pdTerm, "Federate %u of Federation %u sets AttributeRelevanceAdvisorySwitch.",
00409 msg->federate, msg->federation);
00410 }
00411 else {
00412 auditServer << "OFF";
00413 federations.unsetClassRelevanceAdvisorySwitch(msg->federation, msg->federate);
00414 D.Out(pdTerm, "Federate %u of Federation %u clears AttributeRelevanceAdvisorySwitch.",
00415 msg->federate, msg->federation);
00416 }
00417
00418 rep.send(link,NM_msgBufSend);
00419
00420 G.Out(pdGendoc,"END ** SET CLASS RELEVANCE ADVISORY SWITCH **");
00421 G.Out(pdGendoc,"exit RTIG::processSetClassRelevanceAdvisorySwitch");
00422 }
00423
00424
00426 void
00427 RTIG::processSetInteractionRelevanceAdvisorySwitch(Socket *link,
00428 NM_Set_Interaction_Relevance_Advisory_Switch *msg)
00429 {
00430 NM_Set_Interaction_Relevance_Advisory_Switch rep;
00431
00432 G.Out(pdGendoc,"enter RTIG::processSetInteractionRelevanceAdvisorySwitch");
00433 G.Out(pdGendoc,"BEGIN ** SET INTERACTION RELEVANCE ADVISORY SWITCH **");
00434
00435 if (msg->getInteractionRelevanceAdvisorySwitch()) {
00436 auditServer << "ON";
00437 federations.setInteractionRelevanceAdvisorySwitch(msg->federation, msg->federate);
00438 D.Out(pdTerm, "Federate %u of Federation %u sets InteractionRelevanceAdvisorySwitch.",
00439 msg->federate, msg->federation);
00440 }
00441 else {
00442 auditServer << "OFF";
00443 federations.unsetInteractionRelevanceAdvisorySwitch(msg->federation, msg->federate);
00444 D.Out(pdTerm, "Federate %u of Federation %u clears InteractionRelevanceAdvisorySwitch.",
00445 msg->federate, msg->federation);
00446 }
00447
00448 rep.send(link,NM_msgBufSend);
00449
00450 G.Out(pdGendoc,"END ** SET INTERACTION RELEVANCE ADVISORY SWITCH **");
00451 G.Out(pdGendoc,"exit RTIG::processSetInteractionRelevanceAdvisorySwitch");
00452 }
00453
00454
00456 void
00457 RTIG::processSetAttributeRelevanceAdvisorySwitch(Socket *link,
00458 NM_Set_Attribute_Relevance_Advisory_Switch *msg)
00459 {
00460 NM_Set_Attribute_Relevance_Advisory_Switch rep;
00461
00462 G.Out(pdGendoc,"enter RTIG::processSetAttributeRelevanceAdvisorySwitch");
00463 G.Out(pdGendoc,"BEGIN ** SET ATTRIBUTE RELEVANCE ADVISORY SWITCH **");
00464
00465 if (msg->getAttributeRelevanceAdvisorySwitch()) {
00466 auditServer << "ON";
00467 federations.setAttributeRelevanceAdvisorySwitch(msg->federation, msg->federate);
00468 D.Out(pdTerm, "Federate %u of Federation %u sets AttributeRelevanceAdvisorySwitch.",
00469 msg->federate, msg->federation);
00470 }
00471 else {
00472 auditServer << "OFF";
00473 federations.unsetAttributeRelevanceAdvisorySwitch(msg->federation, msg->federate);
00474 D.Out(pdTerm, "Federate %u of Federation %u clears AttributeRelevanceAdvisorySwitch.",
00475 msg->federate, msg->federation);
00476 }
00477
00478 rep.send(link,NM_msgBufSend);
00479
00480 G.Out(pdGendoc,"END ** SET ATTRIBUTE RELEVANCE ADVISORY SWITCH **");
00481 G.Out(pdGendoc,"exit RTIG::processSetAttributeRelevanceAdvisorySwitch");
00482 }
00483
00484
00486 void
00487 RTIG::processSetAttributeScopeAdvisorySwitch(Socket *link,
00488 NM_Set_Attribute_Scope_Advisory_Switch *msg)
00489 {
00490 NM_Set_Attribute_Scope_Advisory_Switch rep;
00491
00492 G.Out(pdGendoc,"enter RTIG::processSetAttributeScopeAdvisorySwitch");
00493 G.Out(pdGendoc,"BEGIN ** SET ATTRIBUTE SCOPE ADVISORY SWITCH **");
00494
00495 if (msg->getAttributeScopeAdvisorySwitch()) {
00496 auditServer << "ON";
00497 federations.setAttributeScopeAdvisorySwitch(msg->federation, msg->federate);
00498 D.Out(pdTerm, "Federate %u of Federation %u sets AttributeScopeAdvisorySwitch.",
00499 msg->federate, msg->federation);
00500 }
00501 else {
00502 auditServer << "OFF";
00503 federations.unsetAttributeScopeAdvisorySwitch(msg->federation, msg->federate);
00504 D.Out(pdTerm, "Federate %u of Federation %u clears AttributeScopeAdvisorySwitch.",
00505 msg->federate, msg->federation);
00506 }
00507
00508 rep.send(link,NM_msgBufSend);
00509
00510 G.Out(pdGendoc,"END ** SET ATTRIBUTE SCOPE ADVISORY SWITCH **");
00511 G.Out(pdGendoc,"exit RTIG::processSetAttributeScopeAdvisorySwitch");
00512 }
00513
00514
00516 void
00517 RTIG::processSetTimeRegulating(Socket *link, NM_Set_Time_Regulating *msg)
00518 {
00519 G.Out(pdGendoc,"enter RTIG::processSetTimeRegulating");
00520 G.Out(pdGendoc,"BEGIN ** SET TIME REGULATING **");
00521
00522 if (msg->isRegulator()) {
00523 auditServer << "ON at time " << msg->getDate().getTime();
00524
00525 federations.createRegulator(msg->federation,
00526 msg->federate,
00527 msg->getDate());
00528
00529
00530 NM_Time_Regulation_Enabled rep ;
00531 rep.federate = msg->federate ;
00532 rep.federation = msg->federation ;
00533 rep.setDate(msg->getDate());
00534
00535 G.Out(pdGendoc," processSetTimeRegulating====> write TRE to RTIA");
00536
00537 rep.send(link,NM_msgBufSend);
00538
00539 D.Out(pdTerm, "Federate %u of Federation %u sets TimeRegulation ON.",
00540 msg->federate, msg->federation);
00541 }
00542 else {
00543 auditServer << "OFF" ;
00544
00545 federations.removeRegulator(msg->federation,
00546 msg->federate);
00547 D.Out(pdTerm, "Federate %u of Federation %u sets TimeRegulation OFF.",
00548 msg->federate, msg->federation);
00549 }
00550
00551 G.Out(pdGendoc,"END ** SET TIME REGULATING **");
00552 G.Out(pdGendoc,"exit RTIG::processSetTimeRegulating");
00553 }
00554
00555
00557 void
00558 RTIG::processSetTimeConstrained(Socket *link, NM_Set_Time_Constrained *msg)
00559 {
00560 G.Out(pdGendoc,"enter RTIG::processSetTimeConstrained");
00561 G.Out(pdGendoc,"BEGIN ** SET TIME CONSTRAINED **");
00562
00563 if (msg->isConstrained()) {
00564 auditServer << "ON at time " << msg->getDate().getTime();
00565
00566 federations.addConstrained(msg->federation,
00567 msg->federate);
00568
00569
00570 NM_Time_Constrained_Enabled rep ;
00571 rep.federate = msg->federate ;
00572 rep.federation = msg->federation ;
00573 rep.setDate(msg->getDate());
00574
00575 G.Out(pdGendoc," processSetTimeConstrained====> write TCE to RTIA");
00576
00577 rep.send(link,NM_msgBufSend);
00578
00579 D.Out(pdTerm, "Federate %u of Federation %u is now constrained.",
00580 msg->federate, msg->federation);
00581 }
00582 else {
00583 auditServer << "OFF" ;
00584
00585 federations.removeConstrained(msg->federation,
00586 msg->federate);
00587 D.Out(pdTerm, "Federate %u of Federation %u is no more constrained.",
00588 msg->federate, msg->federation);
00589 }
00590
00591 G.Out(pdGendoc,"END ** SET TIME CONSTRAINED **");
00592 G.Out(pdGendoc,"exit RTIG::processSetTimeConstrained");
00593 }
00594
00595
00597 void
00598 RTIG::processMessageNull(NetworkMessage *msg)
00599 {
00600 auditServer << "Date " << msg->getDate().getTime();
00601
00602
00603 try {
00604 federations.updateRegulator(msg->federation,
00605 msg->federate,
00606 msg->getDate());
00607 } catch (Exception &e) {}
00608 }
00609
00610
00612 void
00613 RTIG::processRegisterSynchronization(Socket *link, NM_Register_Federation_Synchronization_Point *req)
00614 {
00615
00616 G.Out(pdGendoc,"BEGIN ** REGISTER FEDERATION SYNCHRONIZATION POINT Service **");
00617 G.Out(pdGendoc,"enter RTIG::processRegisterSynchronization");
00618
00619 auditServer << "Label \"" << req->getLabel().c_str() << "\" registered. Tag is \""
00620 << req->getTag().c_str() << "\"" ;
00621
00622
00623 if ( req->doesSetExist() )
00624 federations.manageSynchronization(req->federation,
00625 req->federate,
00626 true,
00627 req->getLabel().c_str(),
00628 req->getTag().c_str(),
00629 req->handleArraySize,
00630 req->handleArray);
00631 else
00632 federations.manageSynchronization(req->federation,
00633 req->federate,
00634 true,
00635 req->getLabel().c_str(),
00636 req->getTag().c_str());
00637 D.Out(pdTerm, "Federation %u is now synchronizing.", req->federation);
00638
00639
00640 NM_Synchronization_Point_Registration_Succeeded rep ;
00641 rep.federate = req->federate ;
00642 rep.federation = req->federation ;
00643 rep.setLabel(req->getLabel().c_str());
00644
00645 G.Out(pdGendoc," processRegisterSynchronization====> write SPRS to RTIA");
00646
00647 rep.send(link,NM_msgBufSend);
00648
00649
00650 if ( req->doesSetExist() )
00651 federations.broadcastSynchronization(req->federation,
00652 req->federate,
00653 req->getLabel().c_str(),
00654 req->getTag().c_str(),
00655 req->handleArraySize,
00656 req->handleArray);
00657 else
00658 federations.broadcastSynchronization(req->federation,
00659 req->federate,
00660 req->getLabel().c_str(),
00661 req->getTag().c_str());
00662
00663 G.Out(pdGendoc,"exit RTIG::processRegisterSynchronization");
00664 G.Out(pdGendoc,"END ** REGISTER FEDERATION SYNCHRONIZATION POINT Service **");
00665
00666 }
00667
00668
00670 void
00671 RTIG::processSynchronizationAchieved(Socket *, NetworkMessage *req)
00672 {
00673 auditServer << "Label \"" << req->getLabel().c_str() << "\" ended." ;
00674
00675 federations.manageSynchronization(req->federation,
00676 req->federate,
00677 false,
00678 req->getLabel().c_str(),
00679 "");
00680 D.Out(pdTerm, "Federate %u has synchronized.", req->federate);
00681 }
00682
00683
00684 void
00685 RTIG::processRequestFederationSave(Socket *, NetworkMessage *req)
00686 {
00687 G.Out(pdGendoc,"BEGIN ** REQUEST FEDERATION SAVE SERVICE **");
00688 G.Out(pdGendoc,"enter RTIG::processRequestFederationSave");
00689
00690 auditServer << "Federation save request." ;
00691
00692 if ( req->isDated() )
00693
00694 federations.requestFederationSave(req->federation, req->federate,
00695 req->getLabel().c_str(), req->getDate());
00696 else
00697
00698 federations.requestFederationSave(req->federation, req->federate,
00699 req->getLabel().c_str());
00700
00701 G.Out(pdGendoc,"exit RTIG::processRequestFederationSave");
00702 G.Out(pdGendoc,"END ** REQUEST FEDERATION SAVE SERVICE **");
00703 }
00704
00705 void
00706 RTIG::processFederateSaveBegun(Socket *, NetworkMessage *req)
00707 {
00708 G.Out(pdGendoc,"enter RTIG::processFederateSaveBegun");
00709 G.Out(pdGendoc,"BEGIN ** FEDERATE SAVE BEGUN SERVICE **");
00710 G.Out(pdGendoc,"processFederateSaveBegun federation = %d",req->federation);
00711
00712 auditServer << "Federate " << req->federate << " save begun." ;
00713
00714 federations.federateSaveBegun(req->federation, req->federate);
00715
00716 G.Out(pdGendoc,"END ** FEDERATE SAVE BEGUN SERVICE **");
00717 G.Out(pdGendoc,"exit RTIG::processFederateSaveBegun");
00718 }
00719
00720
00721 void
00722 RTIG::processFederateSaveStatus(Socket *, NetworkMessage *req)
00723 {
00724 G.Out(pdGendoc,"enter RTIG::processFederateSaveStatus");
00725 if (req->getType() == NetworkMessage::FEDERATE_SAVE_COMPLETE)
00726 G.Out(pdGendoc,"BEGIN ** FEDERATE SAVE COMPLETE SERVICE **");
00727 else
00728 G.Out(pdGendoc,"BEGIN ** FEDERATE SAVE NOT COMPLETE SERVICE **");
00729
00730 auditServer << "Federate " << req->federate << " save ended." ;
00731
00732 bool status = req->getType() == NetworkMessage::FEDERATE_SAVE_COMPLETE ;
00733 federations.federateSaveStatus(req->federation, req->federate, status);
00734
00735 G.Out(pdGendoc,"exit END ** FEDERATE SAVE (NOT) COMPLETE SERVICE **");
00736 G.Out(pdGendoc,"exit RTIG::processFederateSaveStatus");
00737 }
00738
00739
00740 void
00741 RTIG::processRequestFederationRestore(Socket *, NetworkMessage *req)
00742 {
00743 G.Out(pdGendoc,"BEGIN ** REQUEST FEDERATION RESTORE SERVICE **");
00744 G.Out(pdGendoc,"enter RTIG::processRequestFederationRestore");
00745 auditServer << "Federate " << req->federate << " request restore." ;
00746
00747 federations.requestFederationRestore(req->federation, req->federate,
00748 req->getLabel().c_str());
00749 G.Out(pdGendoc,"exit RTIG::processRequestFederationRestore");
00750 G.Out(pdGendoc,"END ** REQUEST FEDERATION RESTORE SERVICE **");
00751 }
00752
00753
00754 void
00755 RTIG::processFederateRestoreStatus(Socket *, NetworkMessage *req)
00756 {
00757 G.Out(pdGendoc,"BEGIN ** FEDERATE RESTORE (NOT)COMPLETE **");
00758 G.Out(pdGendoc,"enter RTIG::processRequestFederateRestoreStatus");
00759 auditServer << "Federate " << req->federate << " restore ended." ;
00760
00761 bool status = req->getType() == NetworkMessage::FEDERATE_RESTORE_COMPLETE ;
00762
00763 federations.federateRestoreStatus(req->federation, req->federate, status);
00764
00765 G.Out(pdGendoc,"exit RTIG::processRequestFederateRestoreStatus");
00766 G.Out(pdGendoc,"END ** FEDERATE RESTORE (NOT)COMPLETE **");
00767 }
00768
00769
00770
00771 void
00772 RTIG::processPublishObjectClass(Socket *link, NetworkMessage *req)
00773 {
00774 bool pub = (req->getType() == NetworkMessage::PUBLISH_OBJECT_CLASS);
00775
00776 auditServer << "Publish Object Class = " << req->objectClass << ", # of att. = "
00777 << req->handleArraySize ;
00778
00779 federations.publishObject(req->federation,
00780 req->federate,
00781 req->objectClass,
00782 req->handleArray,
00783 req->handleArraySize,
00784 pub);
00785
00786 D.Out(pdRegister, "Federate %u of Federation %u published object class %d.",
00787 req->federate, req->federation, req->objectClass);
00788
00789 std::auto_ptr<NetworkMessage> rep(NM_Factory::create(req->getType()));
00790 rep->federate = req->federate ;
00791 rep->objectClass = req->objectClass ;
00792
00793 rep->send(link,NM_msgBufSend);
00794 }
00795
00796
00797
00798 void
00799 RTIG::processSubscribeObjectClass(Socket *link, NetworkMessage *req)
00800 {
00801 G.Out(pdGendoc,"enter RTIG::processSubscribeObjectClass");
00802 G.Out(pdGendoc,"BEGIN ** SUBSCRIBE OBJECT CLASS SERVICE **");
00803
00804 std::vector <AttributeHandle> arrayVide ;
00805 arrayVide.empty() ;
00806 bool sub = (req->getType() == NetworkMessage::SUBSCRIBE_OBJECT_CLASS);
00807
00808 auditServer << "Subscribe Object Class = " << req->objectClass
00809 << ", # of att. = " << req->handleArraySize ;
00810
00811 federations.subscribeObject(req->federation,
00812 req->federate,
00813 req->objectClass,
00814 sub ? req->handleArray : arrayVide,
00815 sub ? req->handleArraySize : 0);
00816
00817 D.Out(pdRegister,
00818 "Federate %u of Federation %u subscribed to object class %d.",
00819 req->federate, req->federation, req->objectClass);
00820
00821 std::auto_ptr<NetworkMessage> rep(NM_Factory::create(req->getType()));
00822 rep->federate = req->federate ;
00823 rep->objectClass = req->objectClass ;
00824 rep->handleArraySize = 0 ;
00825
00826 rep->send(link,NM_msgBufSend);
00827
00828 G.Out(pdGendoc,"END ** SUBSCRIBE OBJECT CLASS SERVICE **");
00829 G.Out(pdGendoc,"exit RTIG::processSubscribeObjectClass");
00830 }
00831
00832
00833
00834 void
00835 RTIG::processPublishInteractionClass(Socket *link, NetworkMessage *req)
00836 {
00837 assert(link != NULL && req != NULL);
00838
00839 bool pub = (req->getType() == NetworkMessage::PUBLISH_INTERACTION_CLASS);
00840
00841 auditServer << "Publish Interaction Class = " << req->interactionClass ;
00842 federations.publishInteraction(req->federation,
00843 req->federate,
00844 req->interactionClass,
00845 pub);
00846 D.Out(pdRequest, "Federate %u of Federation %u publishes Interaction %d.",
00847 req->federate,
00848 req->federation,
00849 req->interactionClass);
00850
00851 std::auto_ptr<NetworkMessage> rep(NM_Factory::create(req->getType())); ;
00852 rep->federate = req->federate ;
00853 rep->interactionClass = req->interactionClass ;
00854
00855 rep->send(link,NM_msgBufSend);
00856 }
00857
00858
00859
00860 void
00861 RTIG::processSubscribeInteractionClass(Socket *link, NetworkMessage *req)
00862 {
00863 bool sub = (req->getType() == NetworkMessage::SUBSCRIBE_INTERACTION_CLASS);
00864
00865 auditServer << "Subscribe Interaction Class = " << req->interactionClass ;
00866 federations.subscribeInteraction(req->federation,
00867 req->federate,
00868 req->interactionClass,
00869 sub);
00870 D.Out(pdRequest,
00871 "Federate %u of Federation %u subscribed to Interaction %d.",
00872 req->federate,
00873 req->federation,
00874 req->interactionClass);
00875
00876 std::auto_ptr<NetworkMessage> rep(NM_Factory::create(req->getType()));;
00877 rep->federate = req->federate ;
00878 rep->interactionClass = req->interactionClass ;
00879
00880 rep->send(link,NM_msgBufSend);
00881 }
00882
00883
00884
00885 void
00886 RTIG::processRegisterObject(Socket *link, NetworkMessage *req)
00887 {
00888 std::auto_ptr<NetworkMessage> rep(NM_Factory::create(req->getType()));;
00889
00890 auditServer << "Register Object Class = " << req->objectClass ;
00891 rep->object = federations.registerObject(req->federation,
00892 req->federate,
00893 req->objectClass,
00894 const_cast<char*>(req->getLabel().c_str()));
00895 auditServer << ", Handle = " << rep->object ;
00896
00897 D.Out(pdRegister,
00898 "Object \"%s\" of Federate %u has been registered under ID %u.",
00899 req->getLabel().c_str(), req->federate, rep->object);
00900
00901 rep->federate = req->federate ;
00902 rep->federation = req->federation;
00903 rep->objectClass = req->objectClass;
00904
00905 rep->setLabel(req->getLabel());
00906
00907 rep->send(link,NM_msgBufSend);
00908 }
00909
00910
00911
00912 void
00913 RTIG::processUpdateAttributeValues(Socket *link, NetworkMessage *req)
00914 {
00915 G.Out(pdGendoc,"enter RTIG::processUpdateAttributeValues");
00916 std::vector <AttributeValue_t> ValueArray ;
00917
00918 auditServer << "ObjID = " << req->object
00919 << ", Date = " << req->getDate().getTime();
00920
00921
00922 ValueArray = req->getAttribValueArray();
00923
00924
00925 if ( req->isDated() )
00926 {
00927
00928 federations.updateAttribute(req->federation,
00929 req->federate,
00930 req->object,
00931 req->handleArray,
00932 ValueArray,
00933 req->handleArraySize,
00934 req->getDate(),
00935 req->getLabel().c_str());
00936 }
00937 else
00938 {
00939
00940 federations.updateAttribute(req->federation,
00941 req->federate,
00942 req->object,
00943 req->handleArray,
00944 ValueArray,
00945 req->handleArraySize,
00946 req->getLabel().c_str());
00947 }
00948 ValueArray.empty();
00949
00950
00951 NM_Update_Attribute_Values rep ;
00952 rep.federate = req->federate ;
00953 rep.object = req->object ;
00954 rep.setDate(req->getDate());
00955 rep.handleArraySize = 0 ;
00956
00957 rep.setLabel(req->getLabel());
00958 rep.setTag(req->getTag());
00959
00960 rep.send(link,NM_msgBufSend);
00961 G.Out(pdGendoc,"exit RTIG::processUpdateAttributeValues");
00962 }
00963
00964
00965
00966 void
00967 RTIG::processSendInteraction(Socket *link, NetworkMessage *req)
00968 {
00969 std::vector <ParameterValue_t> values ;
00970
00971 G.Out(pdGendoc,"BEGIN ** SEND INTERACTION SERVICE **");
00972 G.Out(pdGendoc,"enter RTIG::processSendInteraction");
00973
00974
00975 auditServer << "IntID = " << req->interactionClass
00976 << ", date = " << req->getDate().getTime();
00977 values = req->getParamValueArray();
00978
00979 if ( req->isDated() )
00980 {
00981 federations.updateParameter(req->federation,
00982 req->federate,
00983 req->interactionClass,
00984 req->handleArray,
00985 values,
00986 req->handleArraySize,
00987 req->getDate(),
00988 req->region,
00989 req->getLabel().c_str());
00990 }
00991 else
00992 {
00993 federations.updateParameter(req->federation,
00994 req->federate,
00995 req->interactionClass,
00996 req->handleArray,
00997 values,
00998 req->handleArraySize,
00999 req->region,
01000 req->getLabel().c_str());
01001 }
01002 values.empty();
01003
01004 D.Out(pdDebug, "Interaction %d parameters update completed",
01005 req->interactionClass);
01006
01007 NM_Send_Interaction rep ;
01008 rep.federate = req->federate ;
01009 rep.interactionClass = req->interactionClass ;
01010 rep.handleArraySize = 0 ;
01011
01012 rep.setLabel(req->getLabel());
01013 rep.setTag(req->getTag());
01014 G.Out(pdGendoc,"processSendInteraction===>write");
01015 rep.send(link,NM_msgBufSend);
01016
01017 G.Out(pdGendoc,"exit RTIG::processSendInteraction");
01018 G.Out(pdGendoc,"END ** SEND INTERACTION SERVICE **");
01019
01020 }
01021
01022
01023
01024 void
01025 RTIG::processDeleteObject(Socket *link, NetworkMessage *req)
01026 {
01027 G.Out(pdGendoc,"BEGIN ** DELETE OBJECT INSTANCE service **");
01028 G.Out(pdGendoc,"enter RTIG::processDeleteObject");
01029 auditServer << "Delete ObjID = " << req->object ;
01030
01031 if ( req->isDated() ) {
01032 federations.destroyObject(req->federation,
01033 req->federate,
01034 req->object,
01035 req->getDate(),
01036 const_cast<char*>(req->getLabel().c_str()));
01037 }
01038 else {
01039 federations.destroyObject(req->federation,
01040 req->federate,
01041 req->object,
01042 const_cast<char*>(req->getLabel().c_str()));
01043 }
01044
01045 D.Out(pdRegister, "Object # %u of Federation %u has been deleted.",
01046 req->object, req->federation);
01047
01048 NM_Delete_Object rep ;
01049 rep.federate = req->federate ;
01050 rep.object = req->object ;
01051
01052 rep.send(link,NM_msgBufSend);
01053
01054 G.Out(pdGendoc,"exit RTIG::processDeleteObject");
01055 G.Out(pdGendoc,"END ** DELETE OBJECT INSTANCE **");
01056 }
01057
01058
01059
01060 void
01061 RTIG::processQueryAttributeOwnership(Socket *link, NetworkMessage *req)
01062 {
01063 D.Out(pdDebug, "Owner of Attribute %u of Object %u .",
01064 req->handleArray[0], req->object);
01065
01066 auditServer << "AttributeHandle = " << req->handleArray[0] ;
01067
01068 federations.searchOwner(req->federation,
01069 req->federate,
01070 req->object,
01071 req->handleArray[0]);
01072
01073 D.Out(pdDebug, "Owner of Attribute %u of Object %u .",
01074 req->handleArray[0], req->object);
01075
01076 NM_Query_Attribute_Ownership rep ;
01077 rep.federate = req->federate ;
01078 rep.object = req->object ;
01079
01080 rep.send(link,NM_msgBufSend);
01081 }
01082
01083
01084
01085 void
01086 RTIG::processAttributeOwnedByFederate(Socket *link, NetworkMessage *req)
01087 {
01088 NM_Is_Attribute_Owned_By_Federate rep ;
01089
01090 D.Out(pdDebug, "Owner of Attribute %u of Object %u .",
01091 req->handleArray[0], req->object);
01092
01093 auditServer << "AttributeHandle = " << req->handleArray[0] ;
01094
01095 if (federations.isOwner(req->federation,
01096 req->federate,
01097 req->object,
01098 req->handleArray[0]))
01099 rep.setLabel("RTI_TRUE");
01100 else
01101 rep.setLabel("RTI_FALSE");
01102
01103 D.Out(pdDebug, "Owner of Attribute %u of Object %u .",
01104 req->handleArray[0], req->object);
01105
01106 rep.federate = req->federate ;
01107 rep.object = req->object ;
01108
01109 rep.send(link,NM_msgBufSend);
01110 }
01111
01112
01113
01114 void
01115 RTIG::processNegotiatedOwnershipDivestiture(Socket *link, NetworkMessage *req)
01116 {
01117 auditServer << "Object = " << req->object
01118 << ", # of att. = " << req->handleArraySize ;
01119 federations.negotiateDivestiture(req->federation,
01120 req->federate,
01121 req->object,
01122 req->handleArray,
01123 req->handleArraySize,
01124 req->getLabel().c_str());
01125
01126 D.Out(pdDebug, "Federate %u of Federation %u negotiate "
01127 "divestiture of object %u.",
01128 req->federate, req->federation, req->object);
01129
01130 NM_Negotiated_Attribute_Ownership_Divestiture rep ;
01131 rep.federate = req->federate ;
01132 rep.object = req->object ;
01133 rep.handleArraySize = 0 ;
01134
01135 rep.send(link,NM_msgBufSend);
01136 }
01137
01138
01139
01140 void
01141 RTIG::processAcquisitionIfAvailable(Socket *link, NetworkMessage *req)
01142 {
01143 auditServer << "Object = " << req->object
01144 << ", # of att. = " << req->handleArraySize ;
01145
01146 federations.acquireIfAvailable(req->federation,
01147 req->federate,
01148 req->object,
01149 req->handleArray,
01150 req->handleArraySize);
01151
01152 D.Out(pdDebug,
01153 "Federate %u of Federation %u acquisitionIfAvailable "
01154 "of object %u.",
01155 req->federate, req->federation, req->object);
01156
01157 NM_Attribute_Ownership_Acquisition_If_Available rep ;
01158 rep.federate = req->federate ;
01159 rep.object = req->object ;
01160 rep.handleArraySize = 0 ;
01161
01162 rep.send(link,NM_msgBufSend);
01163 }
01164
01165
01166
01167 void
01168 RTIG::processUnconditionalDivestiture(Socket *link, NetworkMessage *req)
01169 {
01170 auditServer << "Object = " << req->object
01171 << ", # of att. = " << req->handleArraySize ;
01172
01173 federations.divest(req->federation,
01174 req->federate,
01175 req->object,
01176 req->handleArray,
01177 req->handleArraySize);
01178
01179 D.Out(pdDebug,
01180 "Federate %u of Federation %u UnconditionalDivestiture "
01181 "of object %u.",
01182 req->federate, req->federation, req->object);
01183
01184 NM_Unconditional_Attribute_Ownership_Divestiture rep ;
01185 rep.federate = req->federate ;
01186 rep.object = req->object ;
01187 rep.handleArraySize = 0 ;
01188
01189 rep.send(link,NM_msgBufSend);
01190 }
01191
01192
01193
01194 void
01195 RTIG::processOwnershipAcquisition(Socket *link, NetworkMessage *req)
01196 {
01197 auditServer << "Object = " << req->object
01198 << ", # of att. = " << req->handleArraySize ;
01199
01200 federations.acquire(req->federation,
01201 req->federate,
01202 req->object,
01203 req->handleArray,
01204 req->handleArraySize,
01205 req->getLabel().c_str());
01206
01207 D.Out(pdDebug,
01208 "Federate %u of Federation %u ownership acquisition of object %u.",
01209 req->federate, req->federation, req->object);
01210
01211 NM_Attribute_Ownership_Acquisition rep ;
01212 rep.federate = req->federate ;
01213 rep.object = req->object ;
01214 rep.handleArraySize = 0 ;
01215
01216 rep.send(link,NM_msgBufSend);
01217 }
01218
01219
01220
01221 void
01222 RTIG::processCancelNegotiatedDivestiture(Socket *link, NetworkMessage *req)
01223 {
01224 auditServer << "Object = " << req->object
01225 << ", # of att. = " << req->handleArraySize ;
01226
01227 federations.cancelDivestiture(req->federation,
01228 req->federate,
01229 req->object,
01230 req->handleArray,
01231 req->handleArraySize);
01232
01233 D.Out(pdDebug, "Federate %u of Federation %u cancel negotiate "
01234 "divestiture of object %u.",
01235 req->federate, req->federation, req->object);
01236
01237 NM_Cancel_Negotiated_Attribute_Ownership_Divestiture rep ;
01238 rep.federate = req->federate ;
01239 rep.object = req->object ;
01240 rep.handleArraySize = 0 ;
01241
01242 rep.send(link,NM_msgBufSend);
01243 }
01244
01245
01246
01247 void
01248 RTIG::processReleaseResponse(Socket *link, NetworkMessage *req)
01249 {
01250 auditServer << "Object = " << req->object
01251 << ", # of att. = " << req->handleArraySize ;
01252
01253 AttributeHandleSet *attributes =
01254 federations.respondRelease(req->federation,
01255 req->federate,
01256 req->object,
01257 req->handleArray,
01258 req->handleArraySize);
01259
01260 D.Out(pdDebug, "Federate %u of Federation %u release response "
01261 "of object %u.",
01262 req->federate, req->federation, req->object);
01263
01264 NM_Attribute_Ownership_Release_Response rep ;
01265 rep.handleArraySize = attributes->size();
01266 rep.handleArray.resize(rep.handleArraySize) ;
01267
01268 for (unsigned int i = 0 ; i < attributes->size(); i++) {
01269 rep.handleArray[i] = attributes->getHandle(i);
01270 }
01271
01272 rep.federate = req->federate ;
01273 rep.object = req->object ;
01274
01275 rep.send(link,NM_msgBufSend);
01276 }
01277
01278
01279
01280 void
01281 RTIG::processCancelAcquisition(Socket *link, NetworkMessage *req)
01282 {
01283 auditServer << "Object = " << req->object
01284 << ", # of att. = " << req->handleArraySize ;
01285
01286 federations.cancelAcquisition(req->federation,
01287 req->federate,
01288 req->object,
01289 req->handleArray,
01290 req->handleArraySize);
01291
01292 D.Out(pdDebug,
01293 "Federate %u of Federation %u release response of object %u.",
01294 req->federate, req->federation, req->object);
01295
01296 NM_Cancel_Attribute_Ownership_Acquisition rep ;
01297 rep.federate = req->federate ;
01298 rep.object = req->object ;
01299 rep.handleArraySize = 0 ;
01300
01301 rep.send(link,NM_msgBufSend);
01302 }
01303
01304
01305
01306 void
01307 RTIG::processCreateRegion(Socket *link, NetworkMessage *req)
01308 {
01309
01310
01311 NM_DDM_Create_Region rep ;
01312
01313 rep.region = federations.createRegion(req->federation,
01314 req->federate,
01315 req->space,
01316 req->nbExtents);
01317
01318 D[pdDebug] << "Federate " << req->federate << " of Federation "
01319 << req->federation << " creates region " << rep.region
01320 << endl ;
01321
01322 rep.federate = req->federate ;
01323 rep.send(link,NM_msgBufSend);
01324 }
01325
01326
01327
01328 void
01329 RTIG::processModifyRegion(Socket *link, NetworkMessage *req)
01330 {
01331 federations.modifyRegion(req->federation, req->federate,
01332 req->region, req->getExtents());
01333
01334 D[pdDebug] << "Federate " << req->federate << " of Federation "
01335 << req->federation << " modifies region " << req->region
01336 << endl ;
01337
01338 NM_DDM_Modify_Region rep ;
01339 rep.federate = req->federate ;
01340 rep.send(link,NM_msgBufSend);
01341 }
01342
01343
01344
01345 void
01346 RTIG::processDeleteRegion(Socket *link, NetworkMessage *req)
01347 {
01348
01349
01350 federations.deleteRegion(req->federation, req->federate, req->region);
01351
01352 D[pdDebug] << "Federate " << req->federate << " of Federation "
01353 << req->federation << " deletes region " << req->region
01354 << endl ;
01355
01356 NM_DDM_Delete_Region rep ;
01357 rep.federate = req->federate ;
01358 rep.region = req->region ;
01359 rep.send(link,NM_msgBufSend);
01360 }
01361
01362
01363
01364 void
01365 RTIG::processAssociateRegion(Socket *link, NetworkMessage *req)
01366 {
01367
01368
01369 D[pdDebug] << "Federate " << req->federate << " of Federation "
01370 << req->federation << " associates region " << req->region
01371 << " to some attributes of object " << req->object << endl ;
01372
01373 federations.associateRegion(req->federation, req->federate, req->object,
01374 req->region, req->handleArraySize,
01375 req->handleArray);
01376
01377 NM_DDM_Associate_Region rep ;
01378 rep.federate = req->federate ;
01379 rep.send(link,NM_msgBufSend);
01380 }
01381
01382
01383
01384 void
01385 RTIG::processUnassociateRegion(Socket *link, NetworkMessage *req)
01386 {
01387
01388
01389 federations.unassociateRegion(req->federation, req->federate,
01390 req->object, req->region);
01391
01392 D[pdDebug] << "Federate " << req->federate << " of Federation "
01393 << req->federation << " associates region " << req->region
01394 << " from object " << req->object << endl ;
01395
01396 NM_DDM_Unassociate_Region rep ;
01397 rep.federate = req->federate ;
01398 rep.send(link,NM_msgBufSend);
01399 }
01400
01401
01402
01403 void
01404 RTIG::processSubscribeAttributesWR(Socket *link, NetworkMessage *req)
01405 {
01406
01407 D[pdDebug] << "Federate " << req->federate << " of Federation "
01408 << req->federation << " subscribes with region " << req->region
01409 << " to some attributes of class " << req->objectClass << endl ;
01410
01411 federations.subscribeAttributesWR(req->federation, req->federate,
01412 req->objectClass, req->region,
01413 req->handleArraySize, req->handleArray);
01414
01415 NM_DDM_Subscribe_Attributes rep ;
01416 rep.federate = req->federate ;
01417 rep.objectClass = req->objectClass ;
01418 rep.handleArraySize = 0 ;
01419 rep.send(link,NM_msgBufSend);
01420 }
01421
01422
01423
01424 void
01425 RTIG::processUnsubscribeAttributesWR(Socket *link, NetworkMessage *req)
01426 {
01427
01428 D[pdDebug] << "Federate " << req->federate << " of Federation "
01429 << req->federation << " unsubscribes with region " << req->region
01430 << " from object class " << req->objectClass << endl ;
01431
01432 federations.unsubscribeAttributesWR(req->federation, req->federate,
01433 req->objectClass, req->region);
01434
01435 NM_DDM_Unsubscribe_Attributes rep ;
01436 rep.federate = req->federate ;
01437 rep.send(link,NM_msgBufSend);
01438 }
01439
01440
01441
01442 void
01443 RTIG::processSubscribeInteractionWR(Socket *link, NetworkMessage *req)
01444 {
01445
01446
01447 federations.subscribeInteractionWR(req->federation, req->federate,
01448 req->interactionClass, req->region);
01449
01450 D[pdDebug] << "Federate " << req->federate << " of Federation "
01451 << req->federation << " subscribes with region " << req->region
01452 << " to interaction class " << req->interactionClass << endl ;
01453
01454 NM_DDM_Subscribe_Interaction rep ;
01455 rep.federate = req->federate ;
01456 rep.send(link,NM_msgBufSend);
01457 }
01458
01459
01460
01461 void
01462 RTIG::processUnsubscribeInteractionWR(Socket *link, NetworkMessage *req)
01463 {
01464
01465
01466 federations.unsubscribeInteractionWR(req->federation, req->federate,
01467 req->interactionClass, req->region);
01468
01469 D[pdDebug] << "Federate " << req->federate << " of Federation "
01470 << req->federation << " unsubscribes with region " << req->region
01471 << " from interaction class " << req->interactionClass << endl ;
01472
01473 NM_DDM_Unsubscribe_Interaction rep ;
01474 rep.federate = req->federate ;
01475 rep.send(link,NM_msgBufSend);
01476 }
01477
01478
01479
01480 void
01481 RTIG::processRegisterObjectWithRegion(Socket *link, NetworkMessage *req)
01482 {
01483 std::auto_ptr<NetworkMessage> rep(NM_Factory::create(req->getType()));
01484
01485
01486
01487
01488
01489
01490
01491
01492 rep->object = federations.registerObjectWithRegion(req->federation,
01493 req->federate,
01494 req->objectClass,
01495 const_cast<char*>(req->getLabel().c_str()),
01496 req->region,
01497 req->handleArraySize,
01498 req->handleArray);
01499
01500 D.Out(pdRegister,
01501 "Object \"%s\" of Federate %u has been registered under ID %u.",
01502 req->getLabel().c_str(), req->federate, rep->object);
01503
01504 rep->federate = req->federate ;
01505 rep->send(link,NM_msgBufSend);
01506 }
01507
01508
01509
01510 void
01511 RTIG::processRequestObjectAttributeValueUpdate(Socket *link, NetworkMessage *request)
01512 {
01513 NM_Request_Object_Attribute_Value_Update answer ;
01514 Handle federateOwner ;
01515 G.Out(pdGendoc,"enter RTIG::processRequestObjectAttributeValueUpdate");
01516 G.Out(pdGendoc,"BEGIN ** REQUEST OBJECT ATTRIBUTE VALUE UPDATE **");
01517
01518 auditServer << "ObjID = " << request->object ;
01519
01520
01521 answer.exception = e_NO_EXCEPTION ;
01522 try
01523 {
01524 federateOwner = federations.requestObjectOwner(request->federation,
01525 request->federate,
01526 request->object,
01527 request->handleArray,
01528 request->handleArraySize);
01529 }
01530 catch (ObjectNotKnown e)
01531 {
01532 answer.exception = e_ObjectNotKnown ;
01533 answer.exceptionReason = e._reason ;
01534 }
01535 catch (FederationExecutionDoesNotExist e)
01536 {
01537 answer.exception = e_FederationExecutionDoesNotExist ;
01538 answer.exceptionReason = e._reason ;
01539 }
01540 catch (RTIinternalError e)
01541 {
01542 answer.exception = e_RTIinternalError ;
01543 answer.exceptionReason = e._reason ;
01544 }
01545
01546 answer.federate = request->federate ;
01547 answer.object = request->object ;
01548
01549 answer.send(link,NM_msgBufSend);
01550 G.Out(pdGendoc,"exit RTIG::processRequestObjectAttributeValueUpdate");
01551 G.Out(pdGendoc,"END ** REQUEST OBJECT ATTRIBUTE VALUE UPDATE **");
01552 }
01553
01554 }}
01555
01556