00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #ifndef _CERTI_RTIG_FEDERATIONS_LIST_HH
00025 #define _CERTI_RTIG_FEDERATIONS_LIST_HH
00026
00027 #include "Federation.hh"
00028 #include "SocketMC.hh"
00029 #include "SocketServer.hh"
00030 #include "AuditFile.hh"
00031 #include "PrettyDebug.hh"
00032
00033 #include <list>
00034
00035 namespace certi {
00036 namespace rtig {
00037
00040 class FederationsList : private std::list<Federation *>
00041 {
00042 private:
00043 SocketServer &socketServer ;
00044 AuditFile &auditFile ;
00045
00046 public:
00047
00048 FederationsList(SocketServer &, AuditFile &);
00049 ~FederationsList();
00050
00051
00052
00053
00054
00055
00056 #ifdef FEDERATION_USES_MULTICAST
00057 void createFederation(const char *, FederationHandle, SocketMC*)
00058 #else
00059 void createFederation(const char *, Handle, const char *FEDid)
00060 #endif
00061 throw (FederationExecutionAlreadyExists,
00062 CouldNotOpenFED,
00063 ErrorReadingFED,
00064 MemoryExhausted,
00065 SecurityError,
00066 RTIinternalError);
00067
00068 void exists(const char *name, Handle &handle)
00069 throw (FederationExecutionDoesNotExist, RTIinternalError);
00070
00071 void destroyFederation(Handle)
00072 throw (FederatesCurrentlyJoined, FederationExecutionDoesNotExist,
00073 RTIinternalError);
00074
00075 #ifdef FEDERATION_USES_MULTICAST
00076 void info(FederationHandle theHandle,
00077 int &nb_federes,
00078 int &nb_regulateurs,
00079 bool &is_syncing,
00080 SocketMC* &comm_mc)
00081 #else
00082 std::string info(Handle theHandle,
00083 int &nb_federes,
00084 int &nb_regulateurs,
00085 bool &is_syncing)
00086 #endif
00087 throw (FederationExecutionDoesNotExist, RTIinternalError);
00088
00089
00090 void manageSynchronization(Handle theHandle,
00091 FederateHandle theFederate,
00092 bool state,
00093 const char *the_label,
00094 const char *the_tag)
00095 throw (FederationAlreadyPaused,
00096 FederationNotPaused,
00097 FederateNotExecutionMember,
00098 SaveInProgress,
00099 RestoreInProgress,
00100 RTIinternalError);
00101
00102 void manageSynchronization(Handle theHandle,
00103 FederateHandle theFederate,
00104 bool state,
00105 const char *the_label,
00106 const char *the_tag,
00107 unsigned short federate_setSize,
00108 std::vector <FederateHandle> &federate_set)
00109 throw (FederationAlreadyPaused,
00110 FederationNotPaused,
00111 FederateNotExecutionMember,
00112 SaveInProgress,
00113 RestoreInProgress,
00114 RTIinternalError);
00115
00116 void broadcastSynchronization(Handle handle,
00117 FederateHandle federate,
00118 const char *label,
00119 const char *tag)
00120 throw (FederationExecutionDoesNotExist,
00121 RTIinternalError);
00122
00123 void broadcastSynchronization(Handle handle,
00124 FederateHandle federate,
00125 const char *label,
00126 const char *tag,
00127 unsigned short federate_setSize,
00128 std::vector <FederateHandle> &federate_set)
00129 throw (FederationExecutionDoesNotExist,
00130 RTIinternalError);
00131
00132 void requestFederationSave(Handle the_federation,
00133 FederateHandle the_federate,
00134 const char *the_label,
00135 FederationTime the_time);
00136
00137 void requestFederationSave(Handle the_federation,
00138 FederateHandle the_federate,
00139 const char *the_label);
00140
00141 void federateSaveBegun(Handle, FederateHandle);
00142 void federateSaveStatus(Handle, FederateHandle, bool);
00143
00144 void requestFederationRestore(Handle the_federation,
00145 FederateHandle the_federate,
00146 const char *the_label);
00147
00148 void federateRestoreStatus(Handle the_federation,
00149 FederateHandle the_federate,
00150 bool the_status);
00151
00152
00153
00154
00155 FederateHandle addFederate(Handle theHandle,
00156 const char *theFederateName,
00157 SocketTCP *theTCPLink)
00158 throw (FederationExecutionDoesNotExist,
00159 FederateAlreadyExecutionMember,
00160 MemoryExhausted,
00161 RTIinternalError);
00162
00163 void remove(Handle, FederateHandle)
00164 throw (FederationExecutionDoesNotExist,
00165 FederateOwnsAttributes,
00166 FederateNotExecutionMember,
00167 RTIinternalError);
00168
00169 void setClassRelevanceAdvisorySwitch(Handle theHandle,
00170 FederateHandle theFederateHandle)
00171 throw (FederationExecutionDoesNotExist,
00172 FederateNotExecutionMember,
00173 SaveInProgress,
00174 RestoreInProgress,
00175 RTIinternalError);
00176
00177 void unsetClassRelevanceAdvisorySwitch(Handle theHandle,
00178 FederateHandle theFederateHandle)
00179 throw (FederationExecutionDoesNotExist,
00180 FederateNotExecutionMember,
00181 SaveInProgress,
00182 RestoreInProgress,
00183 RTIinternalError);
00184
00185 void setInteractionRelevanceAdvisorySwitch(Handle theHandle,
00186 FederateHandle theFederateHandle)
00187 throw (FederationExecutionDoesNotExist,
00188 FederateNotExecutionMember,
00189 SaveInProgress,
00190 RestoreInProgress,
00191 RTIinternalError);
00192
00193 void unsetInteractionRelevanceAdvisorySwitch(Handle theHandle,
00194 FederateHandle theFederateHandle)
00195 throw (FederationExecutionDoesNotExist,
00196 FederateNotExecutionMember,
00197 SaveInProgress,
00198 RestoreInProgress,
00199 RTIinternalError);
00200
00201 void setAttributeRelevanceAdvisorySwitch(Handle theHandle,
00202 FederateHandle theFederateHandle)
00203 throw (FederationExecutionDoesNotExist,
00204 FederateNotExecutionMember,
00205 SaveInProgress,
00206 RestoreInProgress,
00207 RTIinternalError);
00208
00209 void unsetAttributeRelevanceAdvisorySwitch(Handle theHandle,
00210 FederateHandle theFederateHandle)
00211 throw (FederationExecutionDoesNotExist,
00212 FederateNotExecutionMember,
00213 SaveInProgress,
00214 RestoreInProgress,
00215 RTIinternalError);
00216
00217 void setAttributeScopeAdvisorySwitch(Handle theHandle,
00218 FederateHandle theFederateHandle)
00219 throw (FederationExecutionDoesNotExist,
00220 FederateNotExecutionMember,
00221 SaveInProgress,
00222 RestoreInProgress,
00223 RTIinternalError);
00224
00225 void unsetAttributeScopeAdvisorySwitch(Handle theHandle,
00226 FederateHandle theFederateHandle)
00227 throw (FederationExecutionDoesNotExist,
00228 FederateNotExecutionMember,
00229 SaveInProgress,
00230 RestoreInProgress,
00231 RTIinternalError);
00232
00233 void killFederate(Handle, FederateHandle)
00234 throw ();
00235
00236
00237
00238
00239
00240 void createRegulator(Handle theHandle,
00241 FederateHandle theFederateHandle,
00242 FederationTime theTime)
00243 throw (FederationExecutionDoesNotExist,
00244 FederateNotExecutionMember,
00245 SaveInProgress,
00246 RestoreInProgress,
00247 RTIinternalError);
00248
00249 void updateRegulator(Handle theHandle,
00250 FederateHandle theFederateHandle,
00251 FederationTime heure_logique)
00252 throw (FederationExecutionDoesNotExist,
00253 FederateNotExecutionMember,
00254 RTIinternalError);
00255
00256 void removeRegulator(Handle theHandle,
00257 FederateHandle theFederateHandle)
00258 throw (FederationExecutionDoesNotExist,
00259 FederateNotExecutionMember,
00260 SaveInProgress,
00261 RestoreInProgress,
00262 RTIinternalError);
00263
00264 void addConstrained(Handle theHandle,
00265 FederateHandle theFederateHandle)
00266 throw (FederationExecutionDoesNotExist,
00267 FederateNotExecutionMember,
00268 SaveInProgress,
00269 RestoreInProgress,
00270 RTIinternalError);
00271
00272 void removeConstrained(Handle theHandle,
00273 FederateHandle theFederateHandle)
00274 throw (FederationExecutionDoesNotExist,
00275 FederateNotExecutionMember,
00276 SaveInProgress,
00277 RestoreInProgress,
00278 RTIinternalError);
00279
00280
00281
00282
00283
00284 void publishObject(Handle theHandle,
00285 FederateHandle theFederateHandle,
00286 ObjectClassHandle theObjectHandle,
00287 std::vector <AttributeHandle> &theAttributeList,
00288 UShort theListSize,
00289 bool pub)
00290 throw (ObjectClassNotDefined,
00291 AttributeNotDefined,
00292 FederationExecutionDoesNotExist,
00293 FederateNotExecutionMember,
00294 SaveInProgress,
00295 RestoreInProgress,
00296 SecurityError,
00297 RTIinternalError);
00298
00299 void subscribeObject(Handle theHandle,
00300 FederateHandle theFederateHandle,
00301 ObjectClassHandle theObjectHandle,
00302 std::vector <AttributeHandle> &theAttributeList,
00303 UShort theListSize)
00304 throw (ObjectClassNotDefined,
00305 AttributeNotDefined,
00306 FederationExecutionDoesNotExist,
00307 FederateNotExecutionMember,
00308 SaveInProgress,
00309 RestoreInProgress,
00310 SecurityError,
00311 RTIinternalError);
00312
00313 ObjectHandle registerObject(Handle theHandle,
00314 FederateHandle theFederateHandle,
00315 ObjectClassHandle theClass,
00316 ObjectName_t theName)
00317 throw (FederateNotExecutionMember,
00318 FederateNotPublishing,
00319 ObjectAlreadyRegistered,
00320 ObjectClassNotDefined,
00321 ObjectClassNotPublished,
00322 SaveInProgress,
00323 RestoreInProgress,
00324 RTIinternalError);
00325
00326 FederateHandle requestObjectOwner(Handle handle,
00327 FederateHandle federate,
00328 ObjectHandle id,
00329 std::vector <AttributeHandle> &attributes,
00330 UShort list_size)
00331 throw (ObjectNotKnown,
00332 FederationExecutionDoesNotExist,
00333 RTIinternalError);
00334
00335 void destroyObject(Handle theHandle,
00336 FederateHandle theFederateHandle,
00337 ObjectHandle theObjectHandle,
00338 FederationTime theTime,
00339 const char *theUserTag)
00340 throw (FederateNotExecutionMember,
00341 FederationExecutionDoesNotExist,
00342 DeletePrivilegeNotHeld,
00343 ObjectNotKnown,
00344 SaveInProgress,
00345 RestoreInProgress,
00346 InvalidFederationTime,
00347 RTIinternalError);
00348
00349
00350 void destroyObject(Handle theHandle,
00351 FederateHandle theFederateHandle,
00352 ObjectHandle theObjectHandle,
00353 const char *theUserTag)
00354 throw (FederateNotExecutionMember,
00355 FederationExecutionDoesNotExist,
00356 DeletePrivilegeNotHeld,
00357 ObjectNotKnown,
00358 SaveInProgress,
00359 RestoreInProgress,
00360 RTIinternalError);
00361
00362 void updateAttribute(Handle theHandle,
00363 FederateHandle theFederateHandle,
00364 ObjectHandle theObjectHandle,
00365 std::vector <AttributeHandle> &theAttributeList,
00366 std::vector <AttributeValue_t> &theValueList,
00367 UShort theListSize,
00368 FederationTime theTime,
00369 const char *theTag)
00370 throw (FederateNotExecutionMember,
00371 FederationExecutionDoesNotExist,
00372 ObjectNotKnown,
00373 AttributeNotDefined,
00374 AttributeNotOwned,
00375 SaveInProgress,
00376 RestoreInProgress,
00377 RTIinternalError);
00378
00379 void updateAttribute(Handle theHandle,
00380 FederateHandle theFederateHandle,
00381 ObjectHandle theObjectHandle,
00382 std::vector <AttributeHandle> &theAttributeList,
00383 std::vector <AttributeValue_t> &theValueList,
00384 UShort theListSize,
00385 const char *theTag)
00386 throw (FederateNotExecutionMember,
00387 FederationExecutionDoesNotExist,
00388 ObjectNotKnown,
00389 AttributeNotDefined,
00390 AttributeNotOwned,
00391 SaveInProgress,
00392 RestoreInProgress,
00393 RTIinternalError);
00394
00395
00396
00397
00398
00399 void publishInteraction(Handle theHandle,
00400 FederateHandle theFederateHandle,
00401 InteractionClassHandle theInteractionHandle,
00402 bool publish_or_unpublish)
00403 throw (InteractionClassNotDefined,
00404 FederationExecutionDoesNotExist,
00405 FederateNotExecutionMember,
00406 SaveInProgress,
00407 SecurityError,
00408 RestoreInProgress,
00409 RTIinternalError);
00410
00411 void subscribeInteraction(Handle theHandle,
00412 FederateHandle theFederateHandle,
00413 InteractionClassHandle theInteractionHandle,
00414 bool subscribe_or_unsubscribe)
00415 throw (InteractionClassNotDefined,
00416 FederationExecutionDoesNotExist,
00417 FederateNotExecutionMember,
00418 SaveInProgress,
00419 SecurityError,
00420 RestoreInProgress,
00421 RTIinternalError);
00422
00423 void updateParameter(Handle theFederation,
00424 FederateHandle theFederateHandle,
00425 InteractionClassHandle theInteractionHandle,
00426 std::vector <ParameterHandle> &theParameterList,
00427 std::vector <ParameterValue_t> &theValueList,
00428 UShort theListSize,
00429 FederationTime theTime,
00430 RegionHandle,
00431 const char *theTag)
00432 throw (FederateNotExecutionMember,
00433 FederateNotPublishing,
00434 FederationExecutionDoesNotExist,
00435 InteractionClassNotDefined,
00436 InteractionParameterNotDefined,
00437 SaveInProgress,
00438 RestoreInProgress,
00439 RTIinternalError);
00440
00441 void updateParameter(Handle theFederation,
00442 FederateHandle theFederateHandle,
00443 InteractionClassHandle theInteractionHandle,
00444 std::vector <ParameterHandle> &theParameterList,
00445 std::vector <ParameterValue_t> &theValueList,
00446 UShort theListSize,
00447 RegionHandle,
00448 const char *theTag)
00449 throw (FederateNotExecutionMember,
00450 FederateNotPublishing,
00451 FederationExecutionDoesNotExist,
00452 InteractionClassNotDefined,
00453 InteractionParameterNotDefined,
00454 SaveInProgress,
00455 RestoreInProgress,
00456 RTIinternalError);
00457
00458
00459
00460
00461 bool isOwner(Handle theHandle,
00462 FederateHandle theFederateHandle,
00463 ObjectHandle theObjectHandle,
00464 AttributeHandle theAttribute)
00465 throw (FederateNotExecutionMember,
00466 ObjectNotKnown,
00467 AttributeNotDefined,
00468 SaveInProgress,
00469 RestoreInProgress,
00470 RTIinternalError);
00471
00472 void searchOwner(Handle theHandle,
00473 FederateHandle theFederateHandle,
00474 ObjectHandle theObjectHandle,
00475 AttributeHandle theAttribute)
00476 throw (FederateNotExecutionMember,
00477 ObjectNotKnown,
00478 AttributeNotDefined,
00479 SaveInProgress,
00480 RestoreInProgress,
00481 RTIinternalError);
00482
00483 void negotiateDivestiture(Handle,
00484 FederateHandle,
00485 ObjectHandle,
00486 std::vector <AttributeHandle>&,
00487 UShort,
00488 const char *)
00489 throw (FederateNotExecutionMember,
00490 ObjectNotKnown,
00491 AttributeNotDefined,
00492 AttributeNotOwned,
00493 AttributeAlreadyBeingDivested,
00494 SaveInProgress,
00495 RestoreInProgress,
00496 RTIinternalError);
00497
00498 void acquireIfAvailable(Handle,
00499 FederateHandle,
00500 ObjectHandle,
00501 std::vector <AttributeHandle>&,
00502 UShort)
00503 throw (ObjectNotKnown,
00504 ObjectClassNotPublished,
00505 AttributeNotDefined,
00506 AttributeNotPublished,
00507 FederateOwnsAttributes,
00508 AttributeAlreadyBeingAcquired,
00509 FederateNotExecutionMember,
00510 SaveInProgress,
00511 RestoreInProgress,
00512 RTIinternalError);
00513
00514 void divest(Handle,
00515 FederateHandle,
00516 ObjectHandle,
00517 std::vector <AttributeHandle>&,
00518 UShort)
00519 throw (ObjectNotKnown,
00520 AttributeNotDefined,
00521 AttributeNotOwned,
00522 FederateNotExecutionMember,
00523 SaveInProgress,
00524 RestoreInProgress,
00525 RTIinternalError);
00526
00527 void acquire(Handle theHandle,
00528 FederateHandle theFederateHandle,
00529 ObjectHandle theObjectHandle,
00530 std::vector <AttributeHandle> &theAttributeList,
00531 UShort theListSize,
00532 const char *theTag)
00533 throw (ObjectNotKnown,
00534 ObjectClassNotPublished,
00535 AttributeNotDefined,
00536 AttributeNotPublished,
00537 FederateOwnsAttributes,
00538 FederateNotExecutionMember,
00539 SaveInProgress,
00540 RestoreInProgress,
00541 RTIinternalError);
00542
00543 void cancelDivestiture(Handle theHandle,
00544 FederateHandle theFederateHandle,
00545 ObjectHandle theObjectHandle,
00546 std::vector <AttributeHandle> &theAttributeList,
00547 UShort theListSize)
00548 throw (ObjectNotKnown,
00549 AttributeNotDefined,
00550 AttributeNotOwned,
00551 AttributeDivestitureWasNotRequested,
00552 FederateNotExecutionMember,
00553 SaveInProgress,
00554 RestoreInProgress,
00555 RTIinternalError);
00556
00557 AttributeHandleSet* respondRelease(Handle theHandle,
00558 FederateHandle theFederateHandle,
00559 ObjectHandle theObjectHandle,
00560 std::vector <AttributeHandle> &theAttributeList,
00561 UShort theListSize)
00562 throw (ObjectNotKnown,
00563 AttributeNotDefined,
00564 AttributeNotOwned,
00565 FederateWasNotAskedToReleaseAttribute,
00566 FederateNotExecutionMember,
00567 SaveInProgress,
00568 RestoreInProgress,
00569 RTIinternalError);
00570
00571 void cancelAcquisition(Handle theHandle,
00572 FederateHandle theFederateHandle,
00573 ObjectHandle theObjectHandle,
00574 std::vector <AttributeHandle> &theAttributeList,
00575 UShort theListSize)
00576 throw (ObjectNotKnown,
00577 AttributeNotDefined,
00578 AttributeAlreadyOwned,
00579 AttributeAcquisitionWasNotRequested,
00580 FederateNotExecutionMember,
00581 SaveInProgress,
00582 RestoreInProgress,
00583 RTIinternalError);
00584
00585
00586 long createRegion(Handle, FederateHandle, SpaceHandle, long)
00587 throw (SpaceNotDefined, InvalidExtents, FederateNotExecutionMember,
00588 SaveInProgress, RestoreInProgress, RTIinternalError);
00589
00590 void modifyRegion(Handle, FederateHandle, RegionHandle,
00591 const std::vector<Extent> &)
00592 throw (InvalidExtents, SaveInProgress, RestoreInProgress,
00593 RTIinternalError);
00594
00595 void deleteRegion(Handle, FederateHandle, long)
00596 throw (RegionNotKnown, RegionInUse, FederateNotExecutionMember,
00597 SaveInProgress, RestoreInProgress, RTIinternalError);
00598
00599 void associateRegion(Handle, FederateHandle, ObjectHandle, RegionHandle,
00600 unsigned short, std::vector <AttributeHandle> &)
00601 throw (RegionInUse, FederateNotExecutionMember, SaveInProgress,
00602 RestoreInProgress, RTIinternalError);
00603
00604 void unassociateRegion(Handle, FederateHandle, ObjectHandle, RegionHandle)
00605 throw (RegionInUse, FederateNotExecutionMember, SaveInProgress,
00606 RestoreInProgress, RTIinternalError);
00607
00608 void subscribeAttributesWR(Handle, FederateHandle, ObjectClassHandle,
00609 RegionHandle, unsigned short, std::vector <AttributeHandle> &)
00610 throw (FederateNotExecutionMember, SaveInProgress, RestoreInProgress,
00611 RTIinternalError);
00612
00613 void unsubscribeAttributesWR(Handle, FederateHandle, ObjectClassHandle,
00614 RegionHandle)
00615 throw (FederateNotExecutionMember, SaveInProgress, RestoreInProgress,
00616 RTIinternalError);
00617
00618 void subscribeInteractionWR(Handle, FederateHandle, InteractionClassHandle,
00619 RegionHandle)
00620 throw (FederateNotExecutionMember, SaveInProgress, RestoreInProgress,
00621 RTIinternalError);
00622
00623 void unsubscribeInteractionWR(Handle, FederateHandle,
00624 InteractionClassHandle, RegionHandle)
00625 throw (FederateNotExecutionMember, SaveInProgress, RestoreInProgress,
00626 RTIinternalError);
00627
00628 ObjectHandle registerObjectWithRegion(Handle, FederateHandle,
00629 ObjectClassHandle, ObjectName_t,
00630 RegionHandle, int, std::vector <AttributeHandle> &)
00631 throw (ObjectClassNotDefined, ObjectClassNotPublished,
00632 AttributeNotDefined, AttributeNotPublished, RegionNotKnown,
00633 InvalidRegionContext, ObjectAlreadyRegistered,
00634 FederateNotExecutionMember, SaveInProgress, RestoreInProgress,
00635 RTIinternalError);
00636
00637 void setVerboseLevel(int theVerboseLevel) { this->verboseLevel = theVerboseLevel ; }
00638
00639 private:
00640
00641 void checkHandle(Handle theHandle) throw (RTIinternalError);
00642 int searchFederation(Handle the_handle, Federation* &federation)
00643 throw (FederationExecutionDoesNotExist, RTIinternalError);
00644
00645 int verboseLevel;
00646 };
00647
00648 }}
00649
00650 #endif // _CERTI_RTIG_FEDERATIONS_LIST_HH
00651
00652