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 "OwnershipManagement.hh"
00026
00027 #include "PrettyDebug.hh"
00028 #include "NM_Classes.hh"
00029
00030 #ifdef _WIN32
00031 #include <windows.h>
00032 #else
00033 #include <cstdio>
00034 #include <sys/types.h>
00035 #include <sys/stat.h>
00036 #include <unistd.h>
00037 #include <cstdlib>
00038 #endif
00039 #include <memory>
00040
00041 namespace certi {
00042 namespace rtia {
00043
00044 static pdCDebug D("RTIA_OWM", "(RTIA OwM) ");
00045
00046
00048 OwnershipManagement::OwnershipManagement(Communications *GC,
00049 FederationManagement *GF)
00050 {
00051 comm = GC ;
00052 fm = GF ;
00053 }
00054
00055
00057 OwnershipManagement::~OwnershipManagement()
00058 {
00059 }
00060
00061
00063 const char *
00064 OwnershipManagement::attributeOwnedByFederate(ObjectHandle theObject,
00065 AttributeHandle theAttribute,
00066 TypeException &e)
00067 {
00068 NM_Is_Attribute_Owned_By_Federate req ;
00069
00070 D.Out(pdDebug,
00071 "IS_ATTRIBUTE_OWNED_BY_FEDERATE, attribute %u of object %u",
00072 theAttribute, theObject);
00073
00074 req.federation = fm->_numero_federation ;
00075 req.federate = fm->federate ;
00076 req.object = theObject ;
00077 req.handleArray.resize(1) ;
00078 req.handleArray[0] = theAttribute ;
00079 req.handleArraySize = 1 ;
00080
00081 D.Out(pdDebug, "Federate %u ", fm->federate);
00082
00083 comm->sendMessage(&req);
00084
00085
00086 std::auto_ptr<NetworkMessage> rep(comm->waitMessage(
00087 NetworkMessage::IS_ATTRIBUTE_OWNED_BY_FEDERATE,
00088 req.federate));
00089
00090 e = rep->exception ;
00091
00092 if (e == e_NO_EXCEPTION)
00093 return(rep->getLabel().c_str());
00094 else
00095 return("\0");
00096 }
00097
00098
00100 void
00101 OwnershipManagement::queryAttributeOwnership(ObjectHandle theObject,
00102 AttributeHandle theAttribute,
00103 TypeException &e)
00104 {
00105 NM_Query_Attribute_Ownership req;
00106
00107 D.Out(pdDebug,
00108 "QUERY_ATTRIBUTE_OWNERSHIP, attribute %u from object %u",
00109 theAttribute, theObject);
00110
00111 req.federation = fm->_numero_federation ;
00112 req.federate = fm->federate ;
00113 req.object = theObject ;
00114 req.handleArray.resize(1) ;
00115 req.handleArray[0] = theAttribute ;
00116 req.handleArraySize = 1 ;
00117
00118 D.Out(pdDebug, "Federate %u ", fm->federate);
00119
00120 comm->sendMessage(&req);
00121
00122
00123 std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::QUERY_ATTRIBUTE_OWNERSHIP, req.federate));
00124
00125 e = rep->exception ;
00126 }
00127
00128
00130 void
00131 OwnershipManagement::
00132 negotiatedAttributeOwnershipDivestiture(ObjectHandle theObject,
00133 std::vector <AttributeHandle> &attribArray,
00134 UShort attribArraySize,
00135 std::string theTag,
00136 TypeException &e)
00137
00138 {
00139 NM_Negotiated_Attribute_Ownership_Divestiture req;
00140
00141 req.federation = fm->_numero_federation ;
00142 req.federate = fm->federate ;
00143 req.object = theObject ;
00144 req.handleArray.resize(attribArraySize) ;
00145 req.handleArraySize = attribArraySize ;
00146
00147 for (int i = 0 ; i < attribArraySize ; i++)
00148 req.handleArray[i] = attribArray[i] ;
00149
00150 req.setLabel(theTag);
00151
00152 D.Out(pdDebug, "NEGOTIATED_DIVESTITURE Federate %u ", fm->federate);
00153
00154 comm->sendMessage(&req);
00155
00156 std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::NEGOTIATED_ATTRIBUTE_OWNERSHIP_DIVESTITURE,
00157 req.federate));
00158
00159 e = rep->exception ;
00160 }
00161
00162
00164 void
00165 OwnershipManagement::
00166 cancelnegotiatedAttributeOwnershipDivestiture(ObjectHandle theObject,
00167 std::vector <AttributeHandle> &attribArray,
00168 UShort attribArraySize,
00169 TypeException &e)
00170 {
00171 NM_Cancel_Negotiated_Attribute_Ownership_Divestiture req;
00172
00173 req.federation = fm->_numero_federation ;
00174 req.federate = fm->federate ;
00175 req.object = theObject ;
00176 req.handleArray.resize(attribArraySize) ;
00177 req.handleArraySize = attribArraySize ;
00178
00179 for (int i = 0 ; i < attribArraySize ; i++)
00180 req.handleArray[i] = attribArray[i] ;
00181
00182 D.Out(pdDebug, "CANCEL_NEGOTIATED_DIVESTITURE Federate %u ",
00183 fm->federate);
00184
00185 comm->sendMessage(&req);
00186
00187 std::auto_ptr<NetworkMessage> rep(comm->waitMessage(
00188 NetworkMessage::CANCEL_NEGOTIATED_ATTRIBUTE_OWNERSHIP_DIVESTITURE,
00189 req.federate));
00190
00191 e = rep->exception ;
00192 }
00193
00194
00196 void
00197 OwnershipManagement::
00198 attributeOwnershipAcquisitionIfAvailable(ObjectHandle theObject,
00199 std::vector <AttributeHandle> &attribArray,
00200 UShort attribArraySize,
00201 TypeException &e)
00202 {
00203 NM_Attribute_Ownership_Acquisition_If_Available req;
00204
00205 req.federation = fm->_numero_federation ;
00206 req.federate = fm->federate ;
00207 req.object = theObject ;
00208 req.handleArray.resize(attribArraySize) ;
00209 req.handleArraySize = attribArraySize ;
00210
00211 for (int i = 0 ; i < attribArraySize ; i++)
00212 req.handleArray[i] = attribArray[i] ;
00213
00214 D.Out(pdDebug, "AcquisitionIfAvailable Federate %u ", fm->federate);
00215
00216 comm->sendMessage(&req);
00217
00218 std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::ATTRIBUTE_OWNERSHIP_ACQUISITION_IF_AVAILABLE,
00219 req.federate));
00220
00221 e = rep->exception ;
00222 }
00223
00224
00226 void
00227 OwnershipManagement::
00228 unconditionalAttributeOwnershipDivestiture(ObjectHandle theObject,
00229 std::vector <AttributeHandle> &attribArray,
00230 UShort attribArraySize,
00231 TypeException &e)
00232 {
00233 NM_Unconditional_Attribute_Ownership_Divestiture req;
00234
00235 req.federation = fm->_numero_federation ;
00236 req.federate = fm->federate ;
00237 req.object = theObject ;
00238 req.handleArray.resize(attribArraySize) ;
00239 req.handleArraySize = attribArraySize ;
00240
00241 for (int i = 0 ; i < attribArraySize ; i++)
00242 req.handleArray[i] = attribArray[i] ;
00243
00244 D.Out(pdDebug, "UNCONDITIONAL_DIVESTITURE Federate %u ",
00245 fm->federate);
00246
00247 comm->sendMessage(&req);
00248
00249 std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::UNCONDITIONAL_ATTRIBUTE_OWNERSHIP_DIVESTITURE,
00250 req.federate));
00251
00252 e = rep->exception ;
00253 }
00254
00255
00257 void
00258 OwnershipManagement::
00259 attributeOwnershipAcquisition(ObjectHandle theObject,
00260 std::vector <AttributeHandle> &attribArray,
00261 UShort attribArraySize,
00262 std::string theTag,
00263 TypeException &e)
00264 {
00265 NM_Attribute_Ownership_Acquisition req;
00266
00267 req.federation = fm->_numero_federation ;
00268 req.federate = fm->federate ;
00269 req.object = theObject ;
00270 req.handleArray.resize(attribArraySize) ;
00271 req.handleArraySize = attribArraySize ;
00272
00273 for (int i = 0 ; i < attribArraySize ; i++)
00274 req.handleArray[i] = attribArray[i] ;
00275
00276 req.setLabel(theTag);
00277
00278 D.Out(pdDebug, "OWNERSHIP_ACQUISITION Federate %u ", fm->federate);
00279
00280 comm->sendMessage(&req);
00281
00282 std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::ATTRIBUTE_OWNERSHIP_ACQUISITION,
00283 req.federate));
00284
00285 e = rep->exception ;
00286 }
00287
00288
00290 AttributeHandleSet*
00291 OwnershipManagement::
00292 attributeOwnershipRealeaseResponse(ObjectHandle theObject,
00293 std::vector <AttributeHandle> &attribArray,
00294 UShort attribArraySize,
00295 TypeException &e)
00296 {
00297 NM_Attribute_Ownership_Release_Response req;
00298
00299 req.federation = fm->_numero_federation ;
00300 req.federate = fm->federate ;
00301 req.object = theObject ;
00302 req.handleArray.resize(attribArraySize) ;
00303 req.handleArraySize = attribArraySize ;
00304
00305 D.Out(pdDebug, "RELEASE_RESPONSE Object %u handleArraySize %u",
00306 theObject, req.handleArraySize);
00307
00308 for (int i = 0 ; i < attribArraySize ; i++) {
00309 req.handleArray[i] = attribArray[i] ;
00310 }
00311
00312
00313 comm->sendMessage(&req);
00314
00315 std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::ATTRIBUTE_OWNERSHIP_RELEASE_RESPONSE,
00316 req.federate));
00317
00318 e = rep->exception ;
00319
00320 if (e == e_NO_EXCEPTION) {
00321 AttributeHandleSet *AttributeSet ;
00322 AttributeSet = new AttributeHandleSet(rep->handleArraySize);
00323
00324 for (int i = 0 ; i < rep->handleArraySize ; i++) {
00325 AttributeSet->add(rep->handleArray[i]);
00326 }
00327
00328 return(AttributeSet);
00329 }
00330 else
00331 return NULL ;
00332 }
00333
00334
00336 void
00337 OwnershipManagement::
00338 cancelattributeOwnershipAcquisition(ObjectHandle theObject,
00339 std::vector <AttributeHandle> &attribArray,
00340 UShort attribArraySize,
00341 TypeException &e)
00342 {
00343 NM_Cancel_Attribute_Ownership_Acquisition req;
00344
00345 req.federation = fm->_numero_federation ;
00346 req.federate = fm->federate ;
00347 req.object = theObject ;
00348 req.handleArray.resize(attribArraySize) ;
00349 req.handleArraySize = attribArraySize ;
00350
00351 for (int i = 0 ; i < attribArraySize ; i++)
00352 req.handleArray[i] = attribArray[i] ;
00353
00354 D.Out(pdDebug, "CANCEL_ACQUISITION Federate %u ", fm->federate);
00355
00356 comm->sendMessage(&req);
00357
00358 std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::CANCEL_ATTRIBUTE_OWNERSHIP_ACQUISITION,
00359 req.federate));
00360
00361 e = rep->exception ;
00362 }
00363
00364
00366 void
00367 OwnershipManagement::informAttributeOwnership(ObjectHandle the_object,
00368 AttributeHandle the_attribute,
00369 FederateHandle the_owner,
00370 TypeException &)
00371 {
00372 Message req;
00373
00374 req.type = Message::INFORM_ATTRIBUTE_OWNERSHIP ;
00375 req.setObject(the_object);
00376 req.setAttribute(the_attribute);
00377 req.setFederate(the_owner);
00378
00379 comm->requestFederateService(&req);
00380 }
00381
00382
00384 void
00385 OwnershipManagement::attributeIsNotOwned(ObjectHandle the_object,
00386 AttributeHandle the_attribute,
00387 FederateHandle,
00388 TypeException &)
00389 {
00390 Message req;
00391
00392 req.type = Message::ATTRIBUTE_IS_NOT_OWNED ;
00393 req.setObject(the_object);
00394 req.setAttribute(the_attribute);
00395
00396
00397 comm->requestFederateService(&req);
00398 }
00399
00400
00402 void
00403 OwnershipManagement::
00404 attributeOwnershipUnavailable(ObjectHandle the_object,
00405 std::vector <AttributeHandle> &the_attributes,
00406 UShort the_size,
00407 FederateHandle,
00408 TypeException &)
00409 {
00410 Message req;
00411
00412 req.type = Message::ATTRIBUTE_OWNERSHIP_UNAVAILABLE ;
00413 req.setObject(the_object);
00414 req.setAttributes(the_attributes, the_size);
00415
00416 comm->requestFederateService(&req);
00417 }
00418
00419
00421 void
00422 OwnershipManagement::
00423 attributeOwnershipAcquisitionNotification(ObjectHandle the_object,
00424 std::vector <AttributeHandle> &the_attributes,
00425 UShort the_size,
00426 FederateHandle,
00427 TypeException &)
00428 {
00429 Message req;
00430
00431 req.type = Message::ATTRIBUTE_OWNERSHIP_ACQUISITION_NOTIFICATION ;
00432 req.setObject(the_object);
00433 req.setAttributes(the_attributes, the_size);
00434
00435 comm->requestFederateService(&req);
00436 }
00437
00438
00440 void
00441 OwnershipManagement::
00442 requestAttributeOwnershipAssumption(ObjectHandle the_object,
00443 std::vector <AttributeHandle> &the_attributes,
00444 UShort the_size,
00445 FederateHandle,
00446 std::string the_tag,
00447 TypeException &)
00448 {
00449 Message req;
00450
00451 req.type = Message::REQUEST_ATTRIBUTE_OWNERSHIP_ASSUMPTION ;
00452 req.setObject(the_object);
00453 req.setAttributes(the_attributes, the_size);
00454 req.setTag(the_tag);
00455
00456 comm->requestFederateService(&req);
00457 }
00458
00459
00461 void
00462 OwnershipManagement::
00463 requestAttributeOwnershipRelease(ObjectHandle the_object,
00464 std::vector <AttributeHandle> &the_attributes,
00465 UShort the_size,
00466 std::string the_tag,
00467 TypeException &)
00468 {
00469 Message req;
00470
00471 req.type = Message::REQUEST_ATTRIBUTE_OWNERSHIP_RELEASE ;
00472 req.setObject(the_object);
00473 req.setAttributes(the_attributes, the_size);
00474 req.setTag(the_tag);
00475
00476 comm->requestFederateService(&req);
00477 }
00478
00479
00481 void
00482 OwnershipManagement::
00483 attributeOwnershipDivestitureNotification(ObjectHandle the_object,
00484 std::vector <AttributeHandle> &the_attributes,
00485 UShort the_size,
00486 TypeException &)
00487 {
00488 Message req;
00489
00490 req.type = Message::ATTRIBUTE_OWNERSHIP_DIVESTITURE_NOTIFICATION ;
00491 req.setObject(the_object);
00492 req.setAttributes(the_attributes, the_size);
00493
00494 comm->requestFederateService(&req);
00495 }
00496
00497
00499 void
00500 OwnershipManagement::
00501 confirmAttributeOwnershipAcquisitionCancellation(ObjectHandle the_object,
00502 std::vector <AttributeHandle> &the_attributes,
00503 UShort the_size,
00504 TypeException &)
00505 {
00506 Message req;
00507
00508 req.type = Message::CONFIRM_ATTRIBUTE_OWNERSHIP_ACQUISITION_CANCELLATION ;
00509 req.setObject(the_object);
00510 req.setAttributes(the_attributes, the_size);
00511
00512 comm->requestFederateService(&req);
00513 }
00514
00515 }}
00516
00517