00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #include <config.h>
00024 #include "RTIA.hh"
00025
00026 #include "fed.hh"
00027 #include "RoutingSpace.hh"
00028 #include "XmlParser.hh"
00029 #include <assert.h>
00030 #ifdef _WIN32
00031 #include <time.h>
00032 #include <sys/timeb.h>
00033 #endif
00034
00035 using std::string ;
00036 using std::ifstream ;
00037
00038 namespace certi {
00039 namespace rtia {
00040
00041 static pdCDebug D("RTIA", __FILE__);
00042 static PrettyDebug G("GENDOC",__FILE__) ;
00043
00044
00045 static RTI::TickTime currentTickTime()
00046 {
00047 RTI::TickTime result;
00048 #ifdef _WIN32
00049 _timeb timev;
00050 _ftime(&timev);
00051 result = static_cast<RTI::TickTime>(timev.time + timev.millitm/1000);
00052 #else
00053 struct timeval timev;
00054 gettimeofday(&timev, NULL);
00055 result = timev.tv_sec + timev.tv_usec/1000000;
00056 #endif
00057 return result;
00058 }
00059
00060
00062 void
00063 RTIA::saveAndRestoreStatus(Message::Type type)
00064 throw (SaveInProgress, RestoreInProgress)
00065 {
00066 G.Out(pdGendoc,"enter RTIA::saveAndRestoreStatus");
00067
00068
00069 switch (type) {
00070 case Message::CLOSE_CONNEXION:
00071 case Message::RESIGN_FEDERATION_EXECUTION:
00072 case Message::TICK_REQUEST:
00073 case Message::TICK_REQUEST_NEXT:
00074 case Message::TICK_REQUEST_STOP:
00075 case Message::GET_OBJECT_CLASS_HANDLE:
00076 case Message::GET_OBJECT_CLASS_NAME:
00077 case Message::GET_ATTRIBUTE_HANDLE:
00078 case Message::GET_ATTRIBUTE_NAME:
00079 case Message::GET_INTERACTION_CLASS_HANDLE:
00080 case Message::GET_INTERACTION_CLASS_NAME:
00081 case Message::GET_PARAMETER_HANDLE:
00082 case Message::GET_PARAMETER_NAME:
00083 case Message::GET_OBJECT_INSTANCE_HANDLE:
00084 case Message::GET_OBJECT_INSTANCE_NAME:
00085 case Message::GET_SPACE_HANDLE:
00086 case Message::GET_SPACE_NAME:
00087 case Message::GET_DIMENSION_HANDLE:
00088 case Message::GET_DIMENSION_NAME:
00089 case Message::GET_ATTRIBUTE_SPACE_HANDLE:
00090 case Message::GET_OBJECT_CLASS:
00091 case Message::GET_INTERACTION_SPACE_HANDLE:
00092 case Message::GET_TRANSPORTATION_HANDLE:
00093 case Message::GET_TRANSPORTATION_NAME:
00094 case Message::GET_ORDERING_HANDLE:
00095 case Message::GET_ORDERING_NAME:
00096 break ;
00097 case Message::FEDERATE_SAVE_BEGUN:
00098 case Message::FEDERATE_SAVE_COMPLETE:
00099 case Message::FEDERATE_SAVE_NOT_COMPLETE:
00100 fm->checkFederationRestoring();
00101 break ;
00102 case Message::FEDERATE_RESTORE_COMPLETE:
00103 case Message::FEDERATE_RESTORE_NOT_COMPLETE:
00104 fm->checkFederationSaving();
00105 break ;
00106 default:
00107 fm->checkFederationSaving();
00108 fm->checkFederationRestoring();
00109 }
00110 G.Out(pdGendoc,"exit RTIA::saveAndRestoreStatus");
00111 }
00112
00113
00115 void
00116 RTIA::chooseFederateProcessing(Message *req, Message &rep, TypeException &e)
00117 {
00118 G.Out(pdGendoc,"enter RTIA::chooseFederateProcessing for type = %d",req->type);
00119
00120
00121
00122 saveAndRestoreStatus(req->type);
00123
00124 e = e_NO_EXCEPTION ;
00125
00126 switch(req->type) {
00127
00128 case Message::CLOSE_CONNEXION:
00129 D.Out(pdTrace,
00130 "Receiving Message from Federate, type CloseConnexion.");
00131 fm->_fin_execution = true;
00132
00133 break ;
00134
00135 case Message::CREATE_FEDERATION_EXECUTION:
00136 D.Out(pdTrace,
00137 "Receiving Message from Federate, type CreateFederation.");
00138
00139 fm->_FEDid = req->getFEDid() ;
00140 fm->createFederationExecution(req->getFederationName(), e);
00141 if ( e == e_RTIinternalError )
00142 {
00143 rep.setException(e,"Federate is yet a creator or a member !");
00144 }
00145 D.Out(pdTrace, "Receiving Message from Federate, "
00146 "type CreateFederation done.");
00147
00148 rep.setFEDid(fm->_FEDid) ;
00149
00150 rep.setFederationName(req->getFederationName());
00151 break ;
00152
00153 case Message::DESTROY_FEDERATION_EXECUTION:
00154 D.Out(pdTrace,
00155 "Receiving Message from Federate, type DestroyFederation.");
00156
00157 fm->destroyFederationExecution(req->getFederationName(), e);
00158 if ( e == e_RTIinternalError )
00159 {
00160 rep.setException(e,"Illegal federation handle");
00161 }
00162
00163 rep.setFederationName(req->getFederationName());
00164 break ;
00165
00166 case Message::JOIN_FEDERATION_EXECUTION: {
00167 D.Out(pdTrace,
00168 "Receiving Message from Federate, type JoinFederation.");
00169 rep.setFederate(fm->joinFederationExecution(req->getFederateName(),
00170 req->getFederationName(),
00171 e));
00172 if ( e == e_NO_EXCEPTION )
00173 {
00175 PrettyDebug::setFederateName(req->getFederateName());
00176
00177 rep.setFederationName(req->getFederationName());
00178
00179 string filename = fm->_FEDid ;
00180 int nbcar_filename=filename.length();
00181 bool is_a_fed = false ;
00182 bool is_an_xml = false ;
00183
00184
00185 if ( filename.at(nbcar_filename-4) != '.' )
00186 throw CouldNotOpenFED(". missing or not in place");
00187
00188 string extension = filename.substr(nbcar_filename-3,3) ;
00189 if ( !strcasecmp(extension.c_str(),"fed") )
00190 {
00191 is_a_fed = true ;
00192 D.Out(pdTrace, "Trying to use .fed file");
00193 }
00194 else if ( !strcasecmp(extension.c_str(),"xml") )
00195 {
00196 is_an_xml = true ;
00197 D.Out(pdTrace, "Trying to use .xml file");
00198 }
00199 else
00200 throw CouldNotOpenFED("nor .fed nor .xml");
00201
00202 ifstream fdd(filename.c_str());
00203 if (fdd.is_open())
00204 {
00205 if ( is_a_fed )
00206 {
00207 int result = certi::fedparser::build(filename.c_str(),
00208 rootObject, false);
00209 if (result != 0 ) throw ErrorReadingFED("invalid .fed");
00210 }
00211 else if ( is_an_xml )
00212 {
00213 if (XmlParser::exists())
00214 {
00215 XmlParser parser(rootObject);
00216 parser.parse(filename);
00217 }
00218 else
00219 throw CouldNotOpenFED("no XmlParser");
00220 }
00221 }
00222 else
00223 throw CouldNotOpenFED("File not found");
00224 break ;
00225 }
00226 else
00227 {
00228
00229 throw FederateAlreadyExecutionMember("Federate yet joined or same name");
00230 break;
00231 }
00232 }
00233 case Message::RESIGN_FEDERATION_EXECUTION:
00234 D.Out(pdTrace,
00235 "Receiving Message from Federate, type ResignFederation.");
00236
00237 fm->resignFederationExecution(req->getResignAction(), e);
00238 break ;
00239
00240 case Message::REGISTER_FEDERATION_SYNCHRONIZATION_POINT:
00241 D.Out(pdTrace, "Receiving Message from Federate, type RegisterFederationSynchronizationPoint.");
00242
00243
00244 if ( req->getBoolean() )
00245 fm->registerSynchronization(req->getLabel(), req->getTag(),
00246 (unsigned short)req->handleArraySize, req->handleArray, e);
00247 else
00248 fm->registerSynchronization(req->getLabel(), req->getTag(), e);
00249
00250 rep.setBoolean(req->getBoolean()) ;
00251 break ;
00252
00253 case Message::SYNCHRONIZATION_POINT_ACHIEVED:
00254 D.Out(pdTrace, "Receiving Message from Federate, type SynchronizationPointAchieved.");
00255
00256 fm->unregisterSynchronization(req->getLabel(), e);
00257 break ;
00258
00259 case Message::REQUEST_FEDERATION_SAVE:
00260
00261 if ( req->getBoolean() )
00262 {
00263 D.Out(pdTrace, "Receiving Message from Federate, type"
00264 " RequestFederationSave with time.");
00265 fm->requestFederationSave(req->getLabel(),req->getFederationTime(),
00266 e);
00267 }
00268 else
00269 {
00270 D.Out(pdTrace, "Receiving Message from Federate, type"
00271 " RequestFederationSave without time.");
00272 fm->requestFederationSave(req->getLabel(),e);
00273 }
00274
00275 rep.setBoolean(req->getBoolean()) ;
00276 break ;
00277
00278 case Message::FEDERATE_SAVE_BEGUN:
00279 D.Out(pdTrace, "Receiving Message from Federate, type"
00280 " FederateSaveBegun.");
00281 G.Out(pdGendoc,"chooseFederateProcessing FEDERATE_SAVE_BEGUN");
00282 fm->federateSaveBegun(e);
00283 break ;
00284
00285 case Message::FEDERATE_SAVE_COMPLETE:
00286 case Message::FEDERATE_SAVE_NOT_COMPLETE: {
00287 D.Out(pdTrace, "Receiving Message from Federate, type"
00288 " FederateSave(Not)Complete.");
00289 bool result = req->type == Message::FEDERATE_SAVE_COMPLETE ;
00290 if (result)
00291 {
00292 G.Out(pdGendoc,"chooseFederateProcessing FEDERATE_SAVE_COMPLETE");
00293 }
00294 else
00295 {
00296 G.Out(pdGendoc,"chooseFederateProcessing FEDERATE_SAVE_NOT_COMPLETE");
00297 }
00298 fm->federateSaveStatus(result, e);
00299 }
00300 break ;
00301
00302 case Message::REQUEST_FEDERATION_RESTORE:
00303 D.Out(pdTrace, "Receiving Message from Federate, type"
00304 " RequestFederationRestore.");
00305 G.Out(pdGendoc,"chooseFederateProcessing REQUEST_FEDERATION_RESTORE");
00306
00307 fm->requestFederationRestore(req->getLabel(), e);
00308 break ;
00309
00310 case Message::FEDERATE_RESTORE_COMPLETE:
00311 case Message::FEDERATE_RESTORE_NOT_COMPLETE: {
00312 D.Out(pdTrace, "Receiving Message from Federate, type"
00313 " FederateRestore(Not)Complete.");
00314
00315 bool result = req->type == Message::FEDERATE_RESTORE_COMPLETE ;
00316 if (result)
00317 {
00318 G.Out(pdGendoc,"chooseFederateProcessing FEDERATE_RETORE_COMPLETE");
00319 }
00320 else
00321 {
00322 G.Out(pdGendoc,"chooseFederateProcessing FEDERATE_RESTORE_NOT_COMPLETE");
00323 }
00324 fm->federateRestoreStatus(result, e);
00325 }
00326 break ;
00327
00328 case Message::PUBLISH_OBJECT_CLASS:
00329 D.Out(pdTrace,
00330 "Receiving Message from Federate, type PublishObjectClass.");
00331
00332 dm->publishObjectClass(req->getObjectClass(),
00333 req->handleArray,
00334 req->handleArraySize,
00335 e);
00336 break ;
00337
00338 case Message::UNPUBLISH_OBJECT_CLASS:
00339 D.Out(pdTrace,
00340 "Receiving Message from Federate, type UnpublishObjectClass.");
00341
00342 dm->unpublishObjectClass(req->getObjectClass(), e);
00343 break ;
00344
00345 case Message::PUBLISH_INTERACTION_CLASS:
00346 D.Out(pdTrace,
00347 "Receiving Message from Federate, type PublishInteractionClass.");
00348
00349 dm->publishInteractionClass(req->getInteractionClass(), e);
00350 break ;
00351
00352 case Message::UNPUBLISH_INTERACTION_CLASS:
00353 D.Out(pdTrace,
00354 "Receiving Message from Federate, "
00355 "type UnpublishInteractionClass");
00356
00357 dm->unpublishInteractionClass(req->getInteractionClass(), e);
00358 break ;
00359
00360 case Message::SUBSCRIBE_OBJECT_CLASS_ATTRIBUTES:
00361 D.Out(pdTrace,
00362 "Receiving Message from Federate, type SubscribeObjectClass.");
00363 dm->subscribeObjectClassAttribute(req->getObjectClass(),
00364 req->handleArray,
00365 req->handleArraySize,
00366 e);
00367 break ;
00368
00369 case Message::UNSUBSCRIBE_OBJECT_CLASS:
00370 D.Out(pdTrace,
00371 "Receiving Message from Federate, type UnsubscribeObjectClass.");
00372
00373
00374 dm->unsubscribeObjectClassAttribute(req->getObjectClass(), e);
00375 break ;
00376
00377 case Message::SUBSCRIBE_INTERACTION_CLASS:
00378 D.Out(pdTrace,
00379 "Receiving Message from Federate, type SubscribeInteraction.");
00380
00381 dm->subscribeInteractionClass(req->getInteractionClass(), e);
00382 break ;
00383
00384 case Message::UNSUBSCRIBE_INTERACTION_CLASS:
00385 D.Out(pdTrace,
00386 "Receiving Message from Federate, type UnsubscribeInteraction.");
00387
00388 dm->unsubscribeInteractionClass(req->getInteractionClass(), e);
00389 break ;
00390
00391 case Message::REGISTER_OBJECT_INSTANCE: {
00392 FederationTime date = tm->requestFederateTime();
00393 FederationTime heure = date + tm->requestLookahead();
00394
00395 D.Out(pdTrace,
00396 "Receiving Message from Federate, type RegisterObject.");
00397
00398 rep.setObject(om->registerObject(req->getObjectClass(),
00399 req->getName().c_str(),
00400 date, heure, e));
00401 break ;
00402 }
00403
00404 case Message::UPDATE_ATTRIBUTE_VALUES: {
00405 std::vector <AttributeValue_t> ValueArrayTemp ;
00406 ValueArrayTemp = req->getValueArray();
00407 try {
00408 if (req->getBoolean() )
00409 {
00410 D.Out(pdTrace,"Receiving Message from Federate, type "
00411 "UpdateAttribValues with TIMESTAMP.");
00412 rep.setEventRetraction(
00413 om->updateAttributeValues(req->getObject(),
00414 req->handleArray,
00415 ValueArrayTemp,
00416 req->handleArraySize,
00417 req->getFederationTime(),
00418 req->getTag(),
00419 e));
00420 }
00421 else
00422 {
00423 D.Out(pdTrace,"Receiving Message from Federate, type "
00424 "UpdateAttribValues without TIMESTAMP.");
00425 om->updateAttributeValues(req->getObject(),
00426 req->handleArray,
00427 ValueArrayTemp,
00428 req->handleArraySize,
00429 req->getTag(),
00430 e);
00431 }
00432
00433 rep.setBoolean(req->getBoolean()) ;
00434 ValueArrayTemp.empty() ;
00435 } catch (Exception *e) {
00436 ValueArrayTemp.empty() ;
00437 throw e ;
00438 }
00439 }
00440 break ;
00441
00442 case Message::SEND_INTERACTION: {
00443
00444 std::vector <ParameterValue_t> ValueArrayTemp = req->getValueArray();
00445 G.Out(pdGendoc,"S_I into RTIA::chooseFederateProcessing") ;
00446 try {
00447 if (req->getBoolean() )
00448 {
00449 D.Out(pdTrace,
00450 "Receiving Message from Federate, type SendInteraction with TIMESTAMP.");
00451 rep.setEventRetraction(
00452 om->sendInteraction(req->getInteractionClass(),
00453 req->handleArray,
00454 ValueArrayTemp,
00455 req->handleArraySize,
00456 req->getFederationTime(),
00457 req->getTag(),
00458 req->getRegion(),
00459 e));
00460 }
00461 else
00462 {
00463 D.Out(pdTrace,
00464 "Receiving Message from Federate, type SendInteraction without TIMESTAMP.");
00465 om->sendInteraction(req->getInteractionClass(),
00466 req->handleArray,
00467 ValueArrayTemp,
00468 req->handleArraySize,
00469 req->getTag(),
00470 req->getRegion(),
00471 e);
00472 }
00473 ValueArrayTemp.empty();
00474 } catch (Exception *e) {
00475 ValueArrayTemp.empty();
00476 throw e ;
00477 }
00478 }
00479 break ;
00480
00481 case Message::DELETE_OBJECT_INSTANCE: {
00482
00483 G.Out(pdGendoc,"D_O_I into RTIA::chooseFederateProcessing") ;
00484
00485 try {
00486 if ( req->getBoolean() ) {
00487 D.Out(pdTrace,
00488 "Receiving Message from Federate, type DeleteObjectInstance with \
00489 TIMESTAMP.");
00490 rep.setEventRetraction(
00491 om->deleteObject(
00492 req->getObject(),
00493 req->getFederationTime(),
00494 req->getTag(),
00495 e));
00496 }
00497 else {
00498 D.Out(pdTrace,
00499 "Receiving Message from Federate, type DeleteObjectInstance without \
00500 TIMESTAMP.");
00501 om->deleteObject(
00502 req->getObject(),
00503 req->getTag(),
00504 e);
00505 }
00506 } catch (Exception *e) {
00507 throw e;
00508 }
00509 }
00510 break ;
00511
00512 case Message::CHANGE_ATTRIBUTE_TRANSPORTATION_TYPE:
00513 D.Out(pdTrace,
00514 "Receiving Message from Federate, type ChangeAttribTransport.");
00515
00516 om->changeAttributeTransportType(req->getObject(),
00517 req->handleArray,
00518 req->handleArraySize,
00519 req->getTransportation(),
00520 e);
00521 break ;
00522
00523 case Message::CHANGE_ATTRIBUTE_ORDER_TYPE:
00524 D.Out(pdTrace,
00525 "Receiving Message from Federate, type ChangeAttribOrder.");
00526
00527 om->changeAttributeOrderType(req->getObject(),
00528 req->handleArray,
00529 req->handleArraySize,
00530 req->getOrdering(),
00531 e);
00532 break ;
00533
00534 case Message::CHANGE_INTERACTION_TRANSPORTATION_TYPE:
00535 D.Out(pdTrace,
00536 "Receiving Message from Federate, type ChangeInterTransport.");
00537
00538 om->changeInteractionTransportType(req->getInteractionClass(),
00539 req->getTransportation(),
00540 e);
00541 break ;
00542
00543 case Message::CHANGE_INTERACTION_ORDER_TYPE:
00544 D.Out(pdTrace,
00545 "Receiving Message from Federate, type ChangeInterOrder.");
00546
00547 om->changeInteractionOrderType(req->getInteractionClass(),
00548 req->getOrdering(), e);
00549 break ;
00550
00551 case Message::REQUEST_OBJECT_ATTRIBUTE_VALUE_UPDATE:
00552 D.Out(pdTrace,"Receiving Message from Federate, type "
00553 "RequestAttributeValueUpadate.");
00554 om->requestObjectAttributeValueUpdate(req->getObject(),
00555 req->handleArray,
00556 req->handleArraySize,
00557 e);
00558 break ;
00559
00560 case Message::REQUEST_CLASS_ATTRIBUTE_VALUE_UPDATE:
00561 std::cout<<"request class attribute value update not yet implemented in chooseFederateProcessing"
00562 <<std::endl;
00563 e = e_UnimplementedService ;
00564 break ;
00565
00566 case Message::RETRACT:
00567 std::cout<<"retract not yet implemented in chooseFederateProcessing"<<std::endl;
00568 e = e_UnimplementedService ;
00569 break ;
00570
00571 case Message::UNCONDITIONAL_ATTRIBUTE_OWNERSHIP_DIVESTITURE:
00572 D.Out(pdTrace, "Receiving Message from Federate, "
00573 "type unconditionalAttributeOwnershipDivestiture.");
00574 D.Out(pdTrace, "Object %u number of attributes %u ",
00575 req->getObject(), req->handleArraySize);
00576 owm->unconditionalAttributeOwnershipDivestiture(req->getObject(),
00577 req->handleArray,
00578 req->handleArraySize,
00579 e);
00580 break ;
00581
00582 case Message::NEGOTIATED_ATTRIBUTE_OWNERSHIP_DIVESTITURE:
00583 D.Out(pdTrace, "Receiving Message from Federate, "
00584 "type negotiatedAttributeOwnershipDivestiture.");
00585 D.Out(pdTrace, "Object %u ; %u nb Attribute ", req->getObject(),
00586 req->handleArraySize);
00587 owm->negotiatedAttributeOwnershipDivestiture(req->getObject(),
00588 req->handleArray,
00589 req->handleArraySize,
00590 req->getTag(),
00591 e);
00592 break ;
00593
00594 case Message::ATTRIBUTE_OWNERSHIP_ACQUISITION:
00595 D.Out(pdTrace, "Receiving Message from Federate, "
00596 "type attributeOwnershipAcquisition.");
00597 D.Out(pdTrace, "Object %u ; Nb d'Attributs ", req->getObject(),
00598 req->handleArraySize);
00599 owm->attributeOwnershipAcquisition(req->getObject(),
00600 req->handleArray,
00601 req->handleArraySize,
00602 req->getTag(), e);
00603 break ;
00604
00605 case Message::ATTRIBUTE_OWNERSHIP_RELEASE_RESPONSE:
00606 {
00607 D.Out(pdTrace, "Receiving Message from Federate, "
00608 "type attributeOwnershipRealeaseResponse.");
00609 D.Out(pdTrace, "Object %u nb Attribute %u ",
00610 req->getObject(), req->handleArraySize);
00611
00612 AttributeHandleSet* theAttributes =
00613 owm->attributeOwnershipRealeaseResponse(req->getObject(),
00614 req->handleArray,
00615 req->handleArraySize,
00616 e);
00617 if (e == e_NO_EXCEPTION) {
00618 rep.handleArraySize = theAttributes->size();
00619
00620 for (unsigned int i=0 ; i<theAttributes->size(); i++) {
00621 rep.handleArray[i] = theAttributes->getHandle(i);
00622 }
00623 }
00624 }
00625 break ;
00626
00627 case Message::CANCEL_NEGOTIATED_ATTRIBUTE_OWNERSHIP_DIVESTITURE:
00628 D.Out(pdTrace, "Receiving Message from Federate, "
00629 "type cancelNegociatedAttributeOwnershipDivestiture.");
00630 D.Out(pdTrace, "Object %u nb Attribute %u ",
00631 req->getObject(), req->handleArraySize);
00632 owm->cancelnegotiatedAttributeOwnershipDivestiture(req->getObject(),
00633 req->handleArray,
00634 req->handleArraySize,
00635 e);
00636 break ;
00637
00638
00639 case Message::CANCEL_ATTRIBUTE_OWNERSHIP_ACQUISITION:
00640 D.Out(pdTrace, "Receiving Message from Federate, "
00641 "type cancelAttributeOwnershipAcquisition.");
00642 D.Out(pdTrace, "Object %u nb Attribute %u ",
00643 req->getObject(), req->handleArraySize);
00644 owm->cancelattributeOwnershipAcquisition(req->getObject(),
00645 req->handleArray,
00646 req->handleArraySize,
00647 e);
00648 break ;
00649
00650 case Message::ATTRIBUTE_OWNERSHIP_ACQUISITION_IF_AVAILABLE:
00651 D.Out(pdTrace, "Receiving Message from Federate, "
00652 "type attributeOwnershipAcquisitionIfAvailable.");
00653 D.Out(pdTrace, "Object %u nb Attribute %u ",
00654 req->getObject(), req->handleArraySize);
00655 owm->attributeOwnershipAcquisitionIfAvailable(req->getObject(),
00656 req->handleArray,
00657 req->handleArraySize,
00658 e);
00659 break ;
00660
00661 case Message::QUERY_ATTRIBUTE_OWNERSHIP:
00662 D.Out(pdTrace, "Receiving Message from Federate, "
00663 "type queryAttributeOwnership.");
00664 D.Out(pdTrace, "Object %u Attribute %u ",
00665 req->getObject(), req->getAttribute());
00666 owm->queryAttributeOwnership(req->getObject(), req->getAttribute(), e);
00667
00668 break ;
00669
00670 case Message::IS_ATTRIBUTE_OWNED_BY_FEDERATE:
00671 D.Out(pdTrace, "Receiving Message from Federate, "
00672 "type isAttributeOwnedByFederate.");
00673 D.Out(pdTrace, "Object %u Attribute %u ",
00674 req->getObject(), req->getAttribute());
00675 rep.setTag(owm->attributeOwnedByFederate(req->getObject(),
00676 req->getAttribute(), e));
00677 break ;
00678
00679 case Message::QUERY_LBTS:
00680 D.Out(pdTrace, "Receiving Message from Federate, type RequestLBTS.");
00681
00682 rep.setFederationTime(tm->requestLBTS());
00683 break ;
00684
00685 case Message::ENABLE_ASYNCHRONOUS_DELIVERY:
00686 D.Out(pdTrace, "Receiving Message from Federate, "
00687 "type EnableAsynchronousDelivery.");
00688 if (! tm->_asynchronous_delivery)
00689 tm->_asynchronous_delivery = true ;
00690 else
00691 e = e_AsynchronousDeliveryAlreadyEnabled;
00692 break ;
00693
00694 case Message::DISABLE_ASYNCHRONOUS_DELIVERY:
00695 D.Out(pdTrace, "Receiving Message from Federate, "
00696 "type DisableAsynchronousDelivery.");
00697 if (tm->_asynchronous_delivery)
00698 tm->_asynchronous_delivery = false ;
00699 else
00700 e = e_AsynchronousDeliveryAlreadyDisabled;
00701 break ;
00702
00703
00704 case Message::QUERY_FEDERATE_TIME:
00705 D.Out(pdTrace,
00706 "Receiving Message from Federate, type RequestFederateTime.");
00707
00708 rep.setFederationTime(tm->requestFederateTime());
00709 break ;
00710
00711 case Message::QUERY_MIN_NEXT_EVENT_TIME:
00712 D.Out(pdTrace,
00713 "Receiving Message from Federate, type QueryMinNextEventTime.");
00714
00715 rep.setFederationTime(tm->requestMinNextEventTime());
00716 break ;
00717
00718 case Message::MODIFY_LOOKAHEAD:
00719 D.Out(pdTrace, "Receiving Message from Federate, type SetLookAhead.");
00720
00721 tm->setLookahead(req->getFederationTimeDelta(), e);
00722 break ;
00723
00724 case Message::QUERY_LOOKAHEAD:
00725 D.Out(pdTrace,
00726 "Receiving Message from Federate, type RequestLookAhead.");
00727
00728 rep.setFederationTimeDelta(tm->requestLookahead());
00729 break ;
00730
00731 case Message::TIME_ADVANCE_REQUEST:
00732 D.Out(pdTrace,
00733 "Receiving Message from Federate, type TimeAdvanceRequest.");
00734
00735 tm->timeAdvanceRequest(req->getFederationTime(), e);
00736 break ;
00737
00738 case Message::TIME_ADVANCE_REQUEST_AVAILABLE:
00739 D.Out(pdTrace,
00740 "Receiving Message from Federate, type TimeAdvanceRequestAvailable.");
00741
00742 tm->timeAdvanceRequestAvailable(req->getFederationTime(), e);
00743 break ;
00744
00745 case Message::NEXT_EVENT_REQUEST:
00746 D.Out(pdTrace,
00747 "Receiving Message from Federate, type NestEventRequest.");
00748
00749 tm->nextEventRequest(req->getFederationTime(), e);
00750 break ;
00751
00752 case Message::NEXT_EVENT_REQUEST_AVAILABLE:
00753 D.Out(pdTrace,
00754 "Receiving Message from Federate, type NestEventRequestAvailable.");
00755
00756 tm->nextEventRequestAvailable(req->getFederationTime(), e);
00757 break ;
00758
00759 case Message::FLUSH_QUEUE_REQUEST:
00760 e = e_UnimplementedService ;
00761 break ;
00762
00763
00764
00765 case Message::GET_OBJECT_CLASS_HANDLE:
00766 D.Out(pdTrace,
00767 "Receiving Message from Federate, type GetObjectClassHandle.");
00768 try {
00769 rep.setObjectClass(om->getObjectClassHandle(req->getName().c_str()));
00770 }
00771 catch (Exception &egoch)
00772 {
00773 rep.setException(static_cast<TypeException>(egoch.getType()),egoch._reason);
00774 }
00775 break ;
00776
00777 case Message::GET_OBJECT_CLASS_NAME:
00778 D.Out(pdTrace,
00779 "Receiving Message from Federate, type GetObjectClassName.");
00780
00781 try {
00782 rep.setName(om->getObjectClassName(req->getObjectClass()).c_str());
00783 }
00784 catch (ObjectClassNotDefined) {
00785 rep.setException(e_ObjectClassNotDefined);
00786 }
00787 catch (RTIinternalError) {
00788 rep.setException(e_RTIinternalError);
00789 }
00790 break ;
00791
00792 case Message::GET_OBJECT_INSTANCE_HANDLE:
00793 D.Out(pdTrace,
00794 "Receiving Message from Federate, type getObjectInstanceHandle.");
00795 rep.setObject(om->getObjectInstanceHandle(req->getName().c_str()));
00796 break ;
00797
00798 case Message::GET_OBJECT_INSTANCE_NAME:
00799 D.Out(pdTrace,
00800 "Receiving Message from Federate, type getObjectInstanceName.");
00801
00802 rep.setName(om->getObjectInstanceName(req->getObject()));
00803 break ;
00804
00805
00806
00807 case Message::GET_ATTRIBUTE_HANDLE:
00808 D.Out(pdTrace,
00809 "Receiving Message from Federate, type GetAttributeHandle.");
00810 try {
00811 rep.setAttribute(om->getAttributeHandle(req->getName().c_str(),
00812 req->getObjectClass()));
00813 }
00814 catch (Exception &egah)
00815 {
00816 rep.setException(static_cast<TypeException>(egah.getType()),egah._reason);
00817 }
00818 break ;
00819
00820 case Message::GET_ATTRIBUTE_NAME:
00821 D.Out(pdTrace,
00822 "Receiving Message from Federate, type GetAttributeName.");
00823
00824 rep.setName(om->getAttributeName(req->getAttribute(),
00825 req->getObjectClass()));
00826 break ;
00827
00828 case Message::GET_INTERACTION_CLASS_HANDLE:
00829 D.Out(pdTrace,
00830 "Receiving Message from Federate, type GetInteractionHandle.");
00831
00832 rep.setInteractionClass(om->getInteractionClassHandle(req->getName().c_str()));
00833 break ;
00834
00835 case Message::GET_INTERACTION_CLASS_NAME:
00836 D.Out(pdTrace,
00837 "Receiving Message from Federate, type GetInteractionName.");
00838
00839 rep.setName(om->getInteractionClassName(req->getInteractionClass()).c_str());
00840 break ;
00841
00842 case Message::GET_PARAMETER_HANDLE:
00843 D.Out(pdTrace,
00844 "Receiving Message from Federate, type GetParameterHandle.");
00845
00846 rep.setParameter(om->getParameterHandle(req->getName().c_str(),
00847 req->getInteractionClass()));
00848 break ;
00849
00850 case Message::GET_PARAMETER_NAME:
00851 D.Out(pdTrace,
00852 "Receiving Message from Federate, type GetParameterName.");
00853
00854 rep.setName(om->getParameterName(req->getParameter(),
00855 req->getInteractionClass()).c_str());
00856 break ;
00857
00858 case Message::GET_SPACE_HANDLE:
00859 D.Out(pdTrace, "Receiving Message from Federate, type GetSpaceHandle.");
00860 rep.setSpace(ddm->getRoutingSpaceHandle(req->getName()));
00861 break ;
00862
00863 case Message::GET_SPACE_NAME:
00864 D.Out(pdTrace, "Receiving Message from Federate, type GetSpaceName.");
00865 rep.setName(ddm->getRoutingSpaceName(req->getSpace()).c_str());
00866 break ;
00867
00868 case Message::GET_DIMENSION_HANDLE:
00869 D.Out(pdTrace,
00870 "Receiving Message from Federate, type GetDimensionHandle");
00871 rep.setDimension(ddm->getDimensionHandle(string(req->getName()),
00872 req->getSpace()));
00873 break ;
00874
00875 case Message::GET_DIMENSION_NAME:
00876 D.Out(pdTrace,
00877 "Receiving Message from Federate, type GetDimensionName");
00878 rep.setName(ddm->getDimensionName(req->getDimension(),
00879 req->getSpace()).c_str());
00880 break ;
00881
00882 case Message::GET_ATTRIBUTE_SPACE_HANDLE:
00883 D.Out(pdTrace,
00884 "Receiving Message from Federate, type GetAttributeSpaceHandle");
00885 rep.setSpace(ddm->getAttributeSpace(req->getAttribute(),
00886 req->getObjectClass()));
00887 break ;
00888
00889 case Message::GET_INTERACTION_SPACE_HANDLE:
00890 D.Out(pdTrace,
00891 "Receiving Message from Federate: GetInteractionSpaceHandle");
00892 rep.setSpace(ddm->getInteractionSpace(req->getInteractionClass()));
00893 break ;
00894
00895 case Message::GET_OBJECT_CLASS:
00896 D[pdTrace] << "Message from Federate: getObjectClass" << endl ;
00897 rep.setObjectClass(om->getObjectClass(req->getObject()));
00898 break ;
00899
00900 case Message::GET_TRANSPORTATION_HANDLE:
00901 D[pdTrace] << "Message from Federate: getTransportationHandle" << endl ;
00902 rep.setTransportation(om->getTransportationHandle(req->getName().c_str()));
00903 break ;
00904
00905 case Message::GET_TRANSPORTATION_NAME:
00906 D[pdTrace] << "Message from Federate: getTransportationName" << endl ;
00907 rep.setName(om->getTransportationName(req->getTransportation()));
00908 break ;
00909
00910 case Message::GET_ORDERING_HANDLE:
00911 D[pdTrace] << "Message from Federate: getOrderingHandle" << endl ;
00912 rep.setOrdering(om->getOrderingHandle(req->getName().c_str()));
00913 break ;
00914
00915 case Message::GET_ORDERING_NAME:
00916 D[pdTrace] << "Message from Federate: getOrderingName" << endl ;
00917 rep.setName(om->getOrderingName(req->getOrdering()));
00918 break ;
00919
00920 case Message::DDM_CREATE_REGION:
00921 D[pdTrace] << "Receiving Message from Federate: CreateRegion" << endl ;
00922 rep.setRegion(ddm->createRegion(req->getSpace(), req->getNumber(), e));
00923 rep.setNumber(rootObject->getRoutingSpace(req->getSpace()).size());
00924 break ;
00925
00926 case Message::DDM_MODIFY_REGION:
00927 D[pdTrace] << "Receiving Message from Federate: Modify Region" << endl ;
00928 ddm->modifyRegion(req->getRegion(), req->getExtents(), e);
00929 break ;
00930
00931 case Message::DDM_DELETE_REGION:
00932 D[pdTrace] << "Receiving Message from Federate: DeleteRegion" << endl ;
00933 ddm->deleteRegion(req->getRegion(), e);
00934 break ;
00935
00936 case Message::DDM_ASSOCIATE_REGION:
00937 D[pdTrace] << "Receiving Message from Federate: Associate Region"
00938 << endl ;
00939 ddm->associateRegion(req->getObject(), req->getRegion(),
00940 req->handleArray, req->handleArraySize, e);
00941 break ;
00942
00943 case Message::DDM_REGISTER_OBJECT:
00944 D[pdTrace] << "Receiving Message from Federate: Register with Region"
00945 << endl ;
00946 rep.setObject(ddm->registerObject(req->getObjectClass(),
00947 req->getName(),
00948 req->handleArray,
00949 req->handleArraySize,
00950 req->getRegions(),
00951 e));
00952 break ;
00953
00954 case Message::DDM_UNASSOCIATE_REGION:
00955 D[pdTrace] << "Receiving Message from Federate: Unassociate Region"
00956 << endl ;
00957 ddm->unassociateRegion(req->getObject(), req->getRegion(), e);
00958 break ;
00959
00960 case Message::DDM_SUBSCRIBE_ATTRIBUTES:
00961 D[pdTrace] << "Receiving Message from Federate: Subscribe Attributes"
00962 << endl ;
00963 ddm->subscribe(req->getObjectClass(), req->getRegion(),
00964 req->handleArray, req->handleArraySize, e);
00965 break ;
00966
00967 case Message::DDM_UNSUBSCRIBE_ATTRIBUTES:
00968 D[pdTrace] << "Receiving Message from Federate: Unsubscribe class "
00969 << req->getObjectClass() << endl ;
00970 ddm->unsubscribeAttributes(req->getObjectClass(), req->getRegion(), e);
00971 break ;
00972
00973 case Message::DDM_SUBSCRIBE_INTERACTION:
00974 D[pdTrace] << "Receiving Message from Federate: Subscribe Interaction"
00975 << endl ;
00976 ddm->subscribeInteraction(req->getInteractionClass(),
00977 req->getRegion(), e);
00978 break ;
00979
00980 case Message::DDM_UNSUBSCRIBE_INTERACTION:
00981 D[pdTrace] << "Receiving Message from Federate: Unsubscribe Interaction"
00982 << endl ;
00983 ddm->unsubscribeInteraction(req->getInteractionClass(),
00984 req->getRegion(), e);
00985 break ;
00986
00987 case Message::ENABLE_TIME_REGULATION:
00988 case Message::DISABLE_TIME_REGULATION:
00989 D.Out(pdTrace,
00990 "Receiving Message from Federate, type SetTimeRegulating.");
00991
00992 tm->setTimeRegulating(req->getBoolean(),req->getFederationTime(),req->getFederationTimeDelta(), e);
00993 break ;
00994
00995 case Message::ENABLE_TIME_CONSTRAINED:
00996 case Message::DISABLE_TIME_CONSTRAINED:
00997 D.Out(pdTrace,
00998 "Receiving Message from Federate, type SetTimeConstrained.");
00999
01000 tm->setTimeConstrained(req->getBoolean(), e);
01001 break ;
01002
01003 case Message::TICK_REQUEST:
01004
01005 if (tm->_tick_state != TimeManagement::NO_TICK)
01006 throw RTIinternalError("TICK_REQUEST cannot be called recursively");
01007
01008 tm->_tick_multiple = req->getBoolean();
01009 tm->_tick_result = false;
01010
01011 if (req->getMinTickTime() > 0.0)
01012 {
01013 tm->_tick_timeout = req->getMinTickTime();
01014 tm->_tick_stop_time = currentTickTime() + req->getMaxTickTime();
01015 tm->_tick_state = TimeManagement::TICK_BLOCKING;
01016 }
01017 else
01018 tm->_tick_state = TimeManagement::TICK_CALLBACK;
01019
01020 processOngoingTick();
01021 break ;
01022
01023 case Message::TICK_REQUEST_NEXT:
01024
01025 if (tm->_tick_state != TimeManagement::TICK_CALLBACK &&
01026 tm->_tick_state != TimeManagement::TICK_RETURN)
01027 throw RTIinternalError("unexpected TICK_REQUEST_NEXT");
01028
01029 processOngoingTick();
01030 break ;
01031
01032 case Message::TICK_REQUEST_STOP:
01033
01034
01035 tm->_tick_state = TimeManagement::TICK_RETURN;
01036
01037 processOngoingTick();
01038 break ;
01039
01040 case Message::ENABLE_CLASS_RELEVANCE_ADVISORY_SWITCH:
01041 D.Out(pdTrace,
01042 "Receiving Message from Federate, type EnableClassRelevanceAdvisorySwitch.");
01043 dm->setClassRelevanceAdvisorySwitch(true, e);
01044 break;
01045
01046 case Message::DISABLE_CLASS_RELEVANCE_ADVISORY_SWITCH:
01047 D.Out(pdTrace,
01048 "Receiving Message from Federate, type DisableClassRelevanceAdvisorySwitch.");
01049 dm->setClassRelevanceAdvisorySwitch(false, e);
01050 break;
01051
01052 case Message::ENABLE_INTERACTION_RELEVANCE_ADVISORY_SWITCH:
01053 D.Out(pdTrace,
01054 "Receiving Message from Federate, type SetInteractionRelevanceAdvisorySwitch.");
01055 dm->setInteractionRelevanceAdvisorySwitch(true, e);
01056 break;
01057
01058 case Message::DISABLE_INTERACTION_RELEVANCE_ADVISORY_SWITCH:
01059 D.Out(pdTrace,
01060 "Receiving Message from Federate, type SetInteractionRelevanceAdvisorySwitch.");
01061 dm->setInteractionRelevanceAdvisorySwitch(false, e);
01062 break;
01063
01064 case Message::ENABLE_ATTRIBUTE_RELEVANCE_ADVISORY_SWITCH:
01065 D.Out(pdTrace,
01066 "Receiving Message from Federate, type SetAttributeRelevanceAdvisorySwitch.");
01067 om->setAttributeRelevanceAdvisorySwitch(true, e);
01068 break;
01069
01070 case Message::DISABLE_ATTRIBUTE_RELEVANCE_ADVISORY_SWITCH:
01071 D.Out(pdTrace,
01072 "Receiving Message from Federate, type SetAttributeRelevanceAdvisorySwitch.");
01073 om->setAttributeRelevanceAdvisorySwitch(false, e);
01074 break;
01075
01076 case Message::ENABLE_ATTRIBUTE_SCOPE_ADVISORY_SWITCH:
01077 D.Out(pdTrace,
01078 "Receiving Message from Federate, type SetAttributeScopeAdvisorySwitch.");
01079 om->setAttributeScopeAdvisorySwitch(true, e);
01080 break;
01081
01082 case Message::DISABLE_ATTRIBUTE_SCOPE_ADVISORY_SWITCH:
01083 D.Out(pdTrace,
01084 "Receiving Message from Federate, type SetAttributeScopeAdvisorySwitch.");
01085 om->setAttributeScopeAdvisorySwitch(false, e);
01086 break;
01087
01088 default:
01089 D.Out(pdExcept,
01090 "Receiving Message from Federate, Unknown Type %d.", req->type);
01091 throw RTIinternalError("");
01092 }
01093 stat.federateService(req->type);
01094 G.Out(pdGendoc,"exit chooseFederateProcessing");
01095 }
01096
01097
01099 void
01100 RTIA::processOngoingTick()
01101 {
01102 Message msg_ack;
01103 TypeException exc = e_NO_EXCEPTION;
01104
01105 while (1) {
01106 switch (tm->_tick_state) {
01107 case TimeManagement::TICK_BLOCKING:
01108
01109
01110
01111 tm->_tick_result = tm->tick(exc);
01112
01113 if (tm->_tick_state != TimeManagement::TICK_NEXT)
01114 return;
01115
01116
01117 case TimeManagement::TICK_NEXT:
01118
01119
01120
01121 if (tm->_tick_result &&
01122 tm->_tick_multiple && currentTickTime() < tm->_tick_stop_time)
01123 tm->_tick_state = TimeManagement::TICK_CALLBACK;
01124 else
01125 tm->_tick_state = TimeManagement::TICK_RETURN;
01126
01127 return;
01128
01129 case TimeManagement::TICK_CALLBACK:
01130
01131
01132
01133 tm->_tick_result = tm->tick(exc);
01134
01135 if (tm->_tick_state == TimeManagement::TICK_NEXT)
01136 break;
01137
01138
01139 case TimeManagement::TICK_RETURN:
01140
01141
01142 if ( exc != e_RTIinternalError )
01143 msg_ack.setException(exc);
01144
01145 msg_ack.type = Message::TICK_REQUEST;
01146 msg_ack.setBoolean(tm->_tick_result);
01147 msg_ack.setMinTickTime(0);
01148 msg_ack.setMaxTickTime(0);
01149 comm->requestFederateService(&msg_ack);
01150
01151 tm->_tick_state = TimeManagement::NO_TICK;
01152 return;
01153
01154 default:
01155 std::cerr << "Unknown state: " << tm->_tick_state << std::endl;
01156 assert(false);
01157 }
01158 }
01159 }
01160
01161
01163 void
01164 RTIA::processFederateRequest(Message *req)
01165 {
01166 Message rep ;
01167
01168 G.Out(pdGendoc,"enter RTIA::processFederateRequest");
01169
01170 rep.type = req->type ;
01171
01172 try {
01173 TypeException exc ;
01174 chooseFederateProcessing(req, rep, exc);
01175 if ( exc != e_RTIinternalError && exc != e_NO_EXCEPTION)
01176 rep.setException(exc);
01177 }
01178 catch (ArrayIndexOutOfBounds &e) {
01179 D.Out(pdExcept, "Catched %s Exception.", e._name);
01180 rep.setException(e_ArrayIndexOutOfBounds);
01181 }
01182 catch (AttributeAlreadyOwned &e) {
01183 D.Out(pdExcept, "Catched %s Exception.", e._name);
01184 rep.setException(e_AttributeAlreadyOwned);
01185 }
01186 catch (AttributeAlreadyBeingDivested &e) {
01187 D.Out(pdExcept, "Catched %s Exception.", e._name);
01188 rep.setException(e_AttributeAlreadyBeingDivested);
01189 }
01190 catch (AttributeAlreadyBeingAcquired &e) {
01191 D.Out(pdExcept, "Catched %s Exception.", e._name);
01192 rep.setException(e_AttributeAlreadyBeingAcquired);
01193 }
01194 catch (AttributeAcquisitionWasNotRequested &e) {
01195 D.Out(pdExcept, "Catched %s Exception.", e._name);
01196 rep.setException(e_AttributeAcquisitionWasNotRequested);
01197 }
01198 catch (AttributeDivestitureWasNotRequested &e) {
01199 D.Out(pdExcept, "Catched %s Exception.", e._name);
01200 rep.setException(e_AttributeDivestitureWasNotRequested);
01201 }
01202 catch (AttributeNotDefined &e) {
01203 D.Out(pdExcept, "Catched %s Exception.", e._name);
01204 rep.setException(e_AttributeNotDefined);
01205 }
01206 catch (AttributeNotKnown &e) {
01207 D.Out(pdExcept, "Catched %s Exception.", e._name);
01208 rep.setException(e_AttributeNotKnown);
01209 }
01210 catch (AttributeNotOwned &e) {
01211 D.Out(pdExcept, "Catched %s Exception.", e._name);
01212 rep.setException(e_AttributeNotOwned);
01213 }
01214 catch (AttributeNotPublished &e) {
01215 D.Out(pdExcept, "Catched %s Exception.", e._name);
01216 rep.setException(e_AttributeNotPublished);
01217 }
01218 catch (AttributeNotSubscribed &e) {
01219 D.Out(pdExcept, "Catched %s Exception.", e._name);
01220 rep.setException(e_AttributeNotSubscribed);
01221 }
01222 catch (ConcurrentAccessAttempted &e) {
01223 D.Out(pdExcept, "Catched %s Exception.", e._name);
01224 rep.setException(e_ConcurrentAccessAttempted);
01225 }
01226 catch (CouldNotDiscover &e) {
01227 D.Out(pdExcept, "Catched %s Exception.", e._name);
01228 rep.setException(e_CouldNotDiscover);
01229 }
01230 catch (CouldNotOpenRID &e) {
01231 D.Out(pdExcept, "Catched %s Exception.", e._name);
01232 rep.setException(e_CouldNotOpenRID);
01233 }
01234 catch (CouldNotOpenFED &e) {
01235 D.Out(pdExcept, "Catched %s Exception.", e._name);
01236 rep.setException(e_CouldNotOpenFED,e._reason);
01237 }
01238 catch (CouldNotRestore &e) {
01239 D.Out(pdExcept, "Catched %s Exception.", e._name);
01240 rep.setException(e_CouldNotRestore);
01241 }
01242 catch (DeletePrivilegeNotHeld &e) {
01243 D.Out(pdExcept, "Catched %s Exception.", e._name);
01244 rep.setException(e_DeletePrivilegeNotHeld);
01245 }
01246 catch (ErrorReadingRID &e) {
01247 D.Out(pdExcept, "Catched %s Exception.", e._name);
01248 rep.setException(e_ErrorReadingRID,e._reason);
01249 }
01250 catch (ErrorReadingFED &e) {
01251 D.Out(pdExcept, "Catched %s Exception.", e._name);
01252 rep.setException(e_ErrorReadingFED,e._reason);
01253 }
01254 catch (EventNotKnown &e) {
01255 D.Out(pdExcept, "Catched %s Exception.", e._name);
01256 rep.setException(e_EventNotKnown);
01257 }
01258 catch (FederateAlreadyPaused &e) {
01259 D.Out(pdExcept, "Catched %s Exception.", e._name);
01260 rep.setException(e_FederateAlreadyPaused);
01261 }
01262 catch (FederateAlreadyExecutionMember &e) {
01263 D.Out(pdExcept, "Catched %s Exception.", e._name);
01264 rep.setException(e_FederateAlreadyExecutionMember,e._reason);
01265 }
01266 catch (FederateDoesNotExist &e) {
01267 D.Out(pdExcept, "Catched %s Exception.", e._name);
01268 rep.setException(e_FederateDoesNotExist);
01269 }
01270 catch (FederateInternalError &e) {
01271 D.Out(pdExcept, "Catched %s Exception.", e._name);
01272 rep.setException(e_FederateInternalError);
01273 }
01274 catch (FederateNameAlreadyInUse &e) {
01275 D.Out(pdExcept, "Catched %s Exception.", e._name);
01276 rep.setException(e_FederateNameAlreadyInUse);
01277 }
01278 catch (FederateNotExecutionMember &e) {
01279 D.Out(pdExcept, "Catched %s Exception.", e._name);
01280 rep.setException(e_FederateNotExecutionMember);
01281 }
01282 catch (FederateNotPaused &e) {
01283 D.Out(pdExcept, "Catched %s Exception.", e._name);
01284 rep.setException(e_FederateNotPaused);
01285 }
01286 catch (FederateNotPublishing &e) {
01287 D.Out(pdExcept, "Catched %s Exception.", e._name);
01288 rep.setException(e_FederateNotPublishing);
01289 }
01290 catch (FederateNotSubscribing &e) {
01291 D.Out(pdExcept, "Catched %s Exception.", e._name);
01292 rep.setException(e_FederateNotSubscribing);
01293 }
01294 catch (FederateOwnsAttributes &e) {
01295 D.Out(pdExcept, "Catched %s Exception.", e._name);
01296 rep.setException(e_FederateOwnsAttributes);
01297 }
01298 catch (FederatesCurrentlyJoined &e) {
01299 D.Out(pdExcept, "Catched %s Exception.", e._name);
01300 rep.setException(e_FederatesCurrentlyJoined);
01301 }
01302 catch (FederateWasNotAskedToReleaseAttribute &e) {
01303 D.Out(pdExcept, "Catched %s Exception.", e._name);
01304 rep.setException(e_FederateWasNotAskedToReleaseAttribute);
01305 }
01306 catch (FederationAlreadyPaused &e) {
01307 D.Out(pdExcept, "Catched %s Exception.", e._name);
01308 rep.setException(e_FederationAlreadyPaused);
01309 }
01310 catch (FederationExecutionAlreadyExists &e) {
01311 D.Out(pdExcept, "Catched %s Exception.", e._name);
01312 rep.setException(e_FederationExecutionAlreadyExists,e._reason);
01313 }
01314 catch (FederationExecutionDoesNotExist &e) {
01315 D.Out(pdExcept, "Catched %s Exception.", e._name);
01316 rep.setException(e_FederationExecutionDoesNotExist);
01317 }
01318 catch (FederationNotPaused &e) {
01319 D.Out(pdExcept, "Catched %s Exception.", e._name);
01320 rep.setException(e_FederationNotPaused);
01321 }
01322 catch (FederationTimeAlreadyPassed &e) {
01323 D.Out(pdExcept, "Catched %s Exception.", e._name);
01324 rep.setException(e_FederationTimeAlreadyPassed);
01325 }
01326 catch (IDsupplyExhausted &e) {
01327 D.Out(pdExcept, "Catched %s Exception.", e._name);
01328 rep.setException(e_IDsupplyExhausted);
01329 }
01330 catch (InteractionClassNotDefined &e) {
01331 D.Out(pdExcept, "Catched %s Exception.", e._name);
01332 rep.setException(e_InteractionClassNotDefined);
01333 }
01334 catch (InteractionClassNotKnown &e) {
01335 D.Out(pdExcept, "Catched %s Exception.", e._name);
01336 rep.setException(e_InteractionClassNotKnown);
01337 }
01338 catch (InteractionClassNotPublished &e) {
01339 D.Out(pdExcept, "Catched %s Exception.", e._name);
01340 rep.setException(e_InteractionClassNotPublished);
01341 }
01342 catch (InteractionParameterNotDefined &e) {
01343 D.Out(pdExcept, "Catched %s Exception.", e._name);
01344 rep.setException(e_InteractionParameterNotDefined);
01345 }
01346 catch (InteractionParameterNotKnown &e) {
01347 D.Out(pdExcept, "Catched %s Exception.", e._name);
01348 rep.setException(e_InteractionParameterNotKnown);
01349 }
01350 catch (InvalidDivestitureCondition &e) {
01351 D.Out(pdExcept, "Catched %s Exception.", e._name);
01352 rep.setException(e_InvalidDivestitureCondition);
01353 }
01354 catch (InvalidExtents &e) {
01355 D.Out(pdExcept, "Catched %s Exception.", e._name);
01356 rep.setException(e_InvalidExtents);
01357 }
01358 catch (InvalidFederationTime &e) {
01359 D.Out(pdExcept, "Catched %s Exception.", e._name);
01360 rep.setException(e_InvalidFederationTime);
01361 }
01362 catch (InvalidFederationTimeDelta &e) {
01363 D.Out(pdExcept, "Catched %s Exception.", e._name);
01364 rep.setException(e_InvalidFederationTimeDelta);
01365 }
01366 catch (InvalidObjectHandle &e) {
01367 D.Out(pdExcept, "Catched %s Exception.", e._name);
01368 rep.setException(e_InvalidObjectHandle);
01369 }
01370 catch (InvalidOrderingHandle &e) {
01371 D.Out(pdExcept, "Catched %s Exception.", e._name);
01372 rep.setException(e_InvalidOrderingHandle);
01373 }
01374 catch (InvalidResignAction &e) {
01375 D.Out(pdExcept, "Catched %s Exception.", e._name);
01376 rep.setException(e_InvalidResignAction);
01377 }
01378 catch (InvalidRetractionHandle &e) {
01379 D.Out(pdExcept, "Catched %s Exception.", e._name);
01380 rep.setException(e_InvalidRetractionHandle);
01381 }
01382 catch (InvalidRoutingSpace &e) {
01383 D.Out(pdExcept, "Catched %s Exception.", e._name);
01384 rep.setException(e_InvalidRoutingSpace);
01385 }
01386 catch (InvalidTransportationHandle &e) {
01387 D.Out(pdExcept, "Catched %s Exception.", e._name);
01388 rep.setException(e_InvalidTransportationHandle);
01389 }
01390 catch (MemoryExhausted &e) {
01391 D.Out(pdExcept, "Catched %s Exception.", e._name);
01392 rep.setException(e_MemoryExhausted);
01393 }
01394 catch (NameNotFound &e) {
01395 D.Out(pdExcept, "Catched %s Exception.", e._name);
01396 rep.setException(e_NameNotFound);
01397 }
01398 catch (NoPauseRequested &e) {
01399 D.Out(pdExcept, "Catched %s Exception.", e._name);
01400 rep.setException(e_NoPauseRequested);
01401 }
01402 catch (NoResumeRequested &e) {
01403 D.Out(pdExcept, "Catched %s Exception.", e._name);
01404 rep.setException(e_NoResumeRequested);
01405 }
01406 catch (ObjectClassNotDefined &e) {
01407 D.Out(pdExcept, "Catched %s Exception.", e._name);
01408 rep.setException(e_ObjectClassNotDefined);
01409 }
01410 catch (ObjectClassNotKnown &e) {
01411 D.Out(pdExcept, "Catched %s Exception.", e._name);
01412 rep.setException(e_ObjectClassNotKnown);
01413 }
01414 catch (ObjectClassNotPublished &e) {
01415 D.Out(pdExcept, "Catched %s Exception.", e._name);
01416 rep.setException(e_ObjectClassNotPublished);
01417 }
01418 catch (ObjectClassNotSubscribed &e) {
01419 D.Out(pdExcept, "Catched %s Exception.", e._name);
01420 rep.setException(e_ObjectClassNotSubscribed);
01421 }
01422 catch (ObjectNotKnown &e) {
01423 D.Out(pdExcept, "Catched %s Exception.", e._name);
01424 rep.setException(e_ObjectNotKnown);
01425 }
01426 catch (ObjectAlreadyRegistered &e) {
01427 D.Out(pdExcept, "Catched %s Exception.", e._name);
01428 rep.setException(e_ObjectAlreadyRegistered);
01429 }
01430 catch (RegionNotKnown &e) {
01431 D.Out(pdExcept, "Catched %s Exception.", e._name);
01432 rep.setException(e_RegionNotKnown);
01433 }
01434 catch (RestoreInProgress &e) {
01435 D.Out(pdExcept, "Catched %s Exception.", e._name);
01436 rep.setException(e_RestoreInProgress);
01437 }
01438 catch (RestoreNotRequested &e) {
01439 D.Out(pdExcept, "Catched %s Exception.", e._name);
01440 rep.setException(e_RestoreNotRequested);
01441 }
01442 catch (RTIinternalError &e) {
01443 cout << "RTIA sends InternalError to Fed., " ;
01444 if (!e._reason.empty())
01445 cout << "reason : " << e._reason << endl ;
01446 else
01447 cout << "no reason given." << endl ;
01448 D.Out(pdExcept, "Catched %s Exception.", e._name);
01449 rep.setException(e_RTIinternalError);
01450 }
01451 catch (SpaceNotDefined &e) {
01452 D.Out(pdExcept, "Catched %s Exception.", e._name);
01453 rep.setException(e_SpaceNotDefined);
01454 }
01455 catch (SaveInProgress &e) {
01456 D.Out(pdExcept, "Catched %s Exception.", e._name);
01457 rep.setException(e_SaveInProgress);
01458 }
01459 catch (SaveNotInitiated &e) {
01460 D.Out(pdExcept, "Catched %s Exception.", e._name);
01461 rep.setException(e_SaveNotInitiated);
01462 }
01463 catch (SpecifiedSaveLabelDoesNotExist &e) {
01464 D.Out(pdExcept, "Catched %s Exception.", e._name);
01465 rep.setException(e_SpecifiedSaveLabelDoesNotExist);
01466 }
01467 catch (TimeAdvanceAlreadyInProgress &e) {
01468 D.Out(pdExcept, "Catched %s Exception.", e._name);
01469 rep.setException(e_TimeAdvanceAlreadyInProgress);
01470 }
01471 catch (TimeAdvanceWasNotInProgress &e) {
01472 D.Out(pdExcept, "Catched %s Exception.", e._name);
01473 rep.setException(e_TimeAdvanceWasNotInProgress);
01474 }
01475 catch (TooManyIDsRequested &e) {
01476 D.Out(pdExcept, "Catched %s Exception.", e._name);
01477 rep.setException(e_TooManyIDsRequested);
01478 }
01479 catch (UnableToPerformSave &e) {
01480 D.Out(pdExcept, "Catched %s Exception.", e._name);
01481 rep.setException(e_UnableToPerformSave);
01482 }
01483 catch (UnimplementedService &e) {
01484 D.Out(pdExcept, "Catched %s Exception.", e._name);
01485 rep.setException(e_UnimplementedService);
01486 }
01487 catch (UnknownLabel &e) {
01488 D.Out(pdExcept, "Catched %s Exception.", e._name);
01489 rep.setException(e_UnknownLabel);
01490 }
01491 catch (ValueCountExceeded &e) {
01492 D.Out(pdExcept, "Catched %s Exception.", e._name);
01493 rep.setException(e_ValueCountExceeded);
01494 }
01495 catch (ValueLengthExceeded &e) {
01496 D.Out(pdExcept, "Catched %s Exception.", e._name);
01497 rep.setException(e_ValueLengthExceeded);
01498 }
01499
01500
01501 catch (Exception &e) {
01502 D.Out(pdExcept, "Unknown Exception : %s.", e._name);
01503 rep.setException(e_RTIinternalError);
01504 }
01505
01506 delete req;
01507
01508 if (rep.type != Message::TICK_REQUEST &&
01509 rep.type != Message::TICK_REQUEST_NEXT &&
01510 rep.type != Message::TICK_REQUEST_STOP) {
01511
01512
01513 comm->sendUN(&rep);
01514 D.Out(pdDebug, "Reply send to Unix socket.");
01515 }
01516 G.Out(pdGendoc,"exit RTIA::processFederateRequest");
01517 }
01518
01519 }}
01520