# FederationsList.hh

Go to the documentation of this file.

    00001 // ----------------------------------------------------------------------------
    00002 // CERTI - HLA RunTime Infrastructure
    00003 // Copyright (C) 2002-2005  ONERA
    00004 //
    00005 // This file is part of CERTI
    00006 //
    00007 // CERTI is free software ; you can redistribute it and/or modify
    00008 // it under the terms of the GNU General Public License as published by
    00009 // the Free Software Foundation ; either version 2 of the License, or
    00010 // (at your option) any later version.
    00011 //
    00012 // CERTI is distributed in the hope that it will be useful,
    00013 // but WITHOUT ANY WARRANTY ; without even the implied warranty of
    00014 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    00015 // GNU General Public License for more details.
    00016 //
    00017 // You should have received a copy of the GNU General Public License
    00018 // along with this program ; if not, write to the Free Software
    00019 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
    00020 //
    00021 // $Id: FederationsList.hh,v 3.48 2008/11/20 18:21:56 approx Exp $
    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     // constructor/destructor
    00048     FederationsList(SocketServer &, AuditFile &);
    00049     ~FederationsList();
    00050
    00051     // ---------------------------
    00052     // -- Federation Management --
    00053     // ---------------------------
    00054
    00055     // MAX_FEDERATION is the maximum number of federations.
    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     // Synchronization Management
    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     // -- Federate Management --
    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     // -- Time Management --
    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     // -- Object Classes & Instances Management --
    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     // -- Interactions Classes Management --
    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     // -- Ownership Management --
    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     // Data Distribution Management
    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     // Private methods
    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 }} // namespace certi/rtig
    00649
    00650 #endif // _CERTI_RTIG_FEDERATIONS_LIST_HH
    00651
    00652 // $Id: FederationsList.hh,v 3.48 2008/11/20 18:21:56 approx Exp $