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 $

Generated on Thu Apr 30 15:53:49 2009 for CERTIDeveloperDocumentation by doxygen 1.5.5