ObjectClassSet.cc

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-libCERTI
00006 //
00007 // CERTI-libCERTI is free software ; you can redistribute it and/or
00008 // modify it under the terms of the GNU Lesser General Public License
00009 // as published by the Free Software Foundation ; either version 2 of
00010 // the License, or (at your option) any later version.
00011 //
00012 // CERTI-libCERTI is distributed in the hope that it will be useful, but
00013 // WITHOUT ANY WARRANTY ; without even the implied warranty of
00014 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00015 // Lesser General Public License for more details.
00016 //
00017 // You should have received a copy of the GNU Lesser General Public
00018 // License along with this program ; if not, write to the Free Software
00019 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
00020 // USA
00021 //
00022 // $Id: ObjectClassSet.cc,v 3.45 2008/11/08 11:36:05 erk Exp $
00023 // ----------------------------------------------------------------------------
00024 
00025 // Project
00026 #include "Object.hh"
00027 #include "ObjectClass.hh"
00028 #include "ObjectClassSet.hh"
00029 #include "ObjectClassBroadcastList.hh"
00030 #include "SecurityServer.hh"
00031 #include "PrettyDebug.hh"
00032 #include "Named.hh"
00033 
00034 // Standard
00035 #include <iostream>
00036 #include <sstream>
00037 #include <assert.h>
00038 
00039 using std::list ;
00040 using std::cout ;
00041 using std::endl ;
00042 using std::string ;
00043 
00044 namespace certi {
00045 
00046 static PrettyDebug D("OBJECTCLASSSET", __FILE__);
00047 static PrettyDebug G("GENDOC",__FILE__) ;
00048 
00049 ObjectClassSet::ObjectClassSet(SecurityServer *theSecurityServer, bool isRootClassSet)
00050  : TreeNamedAndHandledSet<ObjectClass>("Object Classes",isRootClassSet)
00051 {
00052     // It can be NULL on the RTIA.
00053     server = theSecurityServer ;
00054 }
00055 
00056 // ----------------------------------------------------------------------------
00058 ObjectClassSet::~ObjectClassSet()
00059 {
00060 
00061 } /* end of ~ObjectClassSet */
00062 
00063 void
00064 ObjectClassSet::addClass(ObjectClass *newClass,ObjectClass *parentClass) throw (RTIinternalError)
00065 {
00066     D.Out(pdInit, "Adding new object class %d.", newClass->getHandle());
00067     /* link to server */
00068     newClass->server = server ;
00069     add(newClass,parentClass);
00070 
00071 } /* end of addClass */
00072 
00073 // ----------------------------------------------------------------------------
00075 void
00076 ObjectClassSet::deleteObject(FederateHandle federate,
00077                              ObjectHandle object,
00078                  FederationTime theTime,
00079                              std::string tag)
00080     throw (DeletePrivilegeNotHeld, ObjectNotKnown, RTIinternalError)
00081 {
00082     // It may throw ObjectNotKnown
00083     ObjectClass *oclass = getInstanceClass(object);
00084 
00085     D.Out(pdRegister,
00086           "Federate %d attempts to delete instance %d in class %d.",
00087           federate, object, oclass->getHandle());
00088 
00089     // It may throw a bunch of exceptions.
00090     ObjectClassBroadcastList *ocbList = oclass->deleteInstance(federate,
00091                                                                object,
00092                                    theTime,
00093                                                                tag);
00094 
00095     // Broadcast RemoveObject message recursively
00096     ObjectClassHandle current_class = 0 ;
00097     if (ocbList != 0) {
00098 
00099         current_class = oclass->getSuperclass();
00100 
00101         while (current_class) {
00102             D.Out(pdRegister,
00103                   "Broadcasting Remove msg to parent class %d for instance %d.",
00104                   current_class, object);
00105 
00106             // It may throw ObjectClassNotDefined
00107             oclass = getObjectFromHandle(current_class);
00108             oclass->broadcastClassMessage(ocbList);
00109 
00110             current_class = oclass->getSuperclass();
00111         }
00112 
00113         delete ocbList ;
00114     }
00115 }
00116 // ----------------------------------------------------------------------------
00118 void
00119 ObjectClassSet::deleteObject(FederateHandle federate,
00120                              ObjectHandle object,
00121                              std::string tag)
00122     throw (DeletePrivilegeNotHeld, ObjectNotKnown, RTIinternalError)
00123 {
00124     // It may throw ObjectNotKnown
00125     ObjectClass *oclass = getInstanceClass(object);
00126 
00127     D.Out(pdRegister,
00128           "Federate %d attempts to delete instance %d in class %d.",
00129           federate, object, oclass->getHandle());
00130 
00131     // It may throw a bunch of exceptions.
00132     ObjectClassBroadcastList *ocbList = oclass->deleteInstance(federate,
00133                                                                object,
00134                                                                tag);
00135 
00136     // Broadcast RemoveObject message recursively
00137     ObjectClassHandle current_class = 0 ;
00138     if (ocbList != 0) {
00139 
00140         current_class = oclass->getSuperclass();
00141 
00142         while (current_class) {
00143             D.Out(pdRegister,
00144                   "Broadcasting Remove msg to parent class %d for instance %d.",
00145                   current_class, object);
00146 
00147             // It may throw ObjectClassNotDefined
00148             oclass = getObjectFromHandle(current_class);
00149             oclass->broadcastClassMessage(ocbList);
00150 
00151             current_class = oclass->getSuperclass();
00152         }
00153 
00154         delete ocbList ;
00155     }
00156 
00157     D.Out(pdRegister, "Instance %d has been deleted.", object);
00158 }
00159 
00160 // ----------------------------------------------------------------------------
00162 AttributeHandle
00163 ObjectClassSet::getAttributeHandle(const char *the_name,
00164                                    ObjectClassHandle the_class) const
00165     throw (NameNotFound, ObjectClassNotDefined, RTIinternalError)
00166 {
00167     G.Out(pdGendoc,"enter ObjectClassSet::getAttributeHandle");
00168 
00169     ObjectClass *objectClass = 0 ;
00170     AttributeHandle handle ;
00171 
00172     if (the_name == 0)
00173         throw RTIinternalError("name is null");
00174 
00175     D.Out(pdRequest, "Looking for attribute \"%s\" of class %u...",
00176           the_name, the_class);
00177 
00178     // It may throw ObjectClassNotDefined.
00179     objectClass = getObjectFromHandle(the_class);
00180 
00181 
00182     try
00183         {
00184          handle = objectClass->getAttributeHandle(the_name);
00185          G.Out(pdGendoc,"exit ObjectClassSet::getAttributeHandle");
00186          return handle ;
00187          }
00188     catch ( NameNotFound )
00189          {
00190          G.Out(pdGendoc,"exit  ObjectClassset::getAttributeHandle on NameNotFound");
00191          throw NameNotFound (the_name) ;
00192          }
00193 }
00194 
00195 // ----------------------------------------------------------------------------
00197 const char *
00198 ObjectClassSet::getAttributeName(AttributeHandle the_handle,
00199                                  ObjectClassHandle the_class) const
00200     throw (AttributeNotDefined,
00201            ObjectClassNotDefined,
00202            RTIinternalError)
00203 {
00204     ObjectClass *objectClass = NULL ;
00205 
00206     D.Out(pdRequest, "Looking for attribute %u of class %u...",
00207           the_handle, the_class);
00208 
00209     // It may throw ObjectClassNotDefined.
00210     objectClass = getObjectFromHandle(the_class);
00211 
00212     return objectClass->getAttributeName(the_handle);
00213 }
00214 
00215 // ----------------------------------------------------------------------------
00217 ObjectClass *
00218 ObjectClassSet::getInstanceClass(ObjectHandle theObjectHandle) const
00219     throw (ObjectNotKnown)
00220 {
00221     std::stringstream msg;
00222 
00223     handled_const_iterator i ;
00224     for (i = fromHandle.begin(); i != fromHandle.end(); ++i) {
00225         if (i->second->isInstanceInClass(theObjectHandle) == true)
00226             return (i->second);
00227     }
00228 
00229     msg << "ObjectHandle <" << theObjectHandle <<"> not found in any object class.";
00230     D.Out(pdExcept, msg.str().c_str());
00231     throw ObjectNotKnown(msg.str().c_str());
00232 }
00233 
00234 // ----------------------------------------------------------------------------
00237 Object *
00238 ObjectClassSet::getObject(ObjectHandle h) const
00239     throw (ObjectNotKnown)
00240 {
00241 
00242     handled_const_iterator i ;
00243 
00244     for (i = fromHandle.begin(); i != fromHandle.end(); ++i) {
00245         try {
00246             Object *object = i->second->getInstanceWithID(h);
00247             return object ;
00248         }
00249         catch (ObjectNotKnown &e) {
00250         }
00251     }
00252     throw ObjectNotKnown("");
00253 }
00254 
00255 // ----------------------------------------------------------------------------
00257 ObjectClassHandle
00258 ObjectClassSet::getObjectClassHandle(std::string class_name) const
00259 throw (NameNotFound){
00260     return getHandleFromName(class_name);
00261 } /* end of getObjectClassHandle */
00262 
00263 // ----------------------------------------------------------------------------
00265 string
00266 ObjectClassSet::getObjectClassName(ObjectClassHandle the_handle) const
00267     throw (ObjectClassNotDefined)
00268 {
00269     D.Out(pdRequest, "Looking for class %u...", the_handle);
00270     return getNameFromHandle(the_handle);
00271 }
00272 
00273 // ----------------------------------------------------------------------------
00275 void ObjectClassSet::killFederate(FederateHandle theFederate)
00276     throw ()
00277 {
00278     ObjectClassBroadcastList *ocbList      = NULL ;
00279     ObjectClassHandle         currentClass = 0 ;
00280 
00281     handled_iterator i;
00282 
00283     for (i = fromHandle.begin(); i != fromHandle.end(); ++i) {
00284         // Call KillFederate on that class until it returns NULL.
00285         do {
00286             D.Out(pdExcept, "Kill Federate Handle %d .", theFederate);
00287             ocbList = i->second->killFederate(theFederate);
00288 
00289             D.Out(pdExcept, "Federate Handle %d Killed.", theFederate);
00290 
00291             // Broadcast RemoveObject message recursively
00292             if (ocbList != 0) {
00293                 currentClass = i->second->getSuperclass();
00294                 D.Out(pdExcept, "List not NULL");
00295                 while (currentClass != 0) {
00296                     D.Out(pdRegister,
00297                           "Broadcasting Remove msg to parent class %d(Killed).",
00298                           currentClass);
00299 
00300                     // It may throw ObjectClassNotDefined
00301                     i->second = getObjectFromHandle(currentClass);
00302 
00303                     i->second->broadcastClassMessage(ocbList);
00304 
00305                     currentClass = i->second->getSuperclass();
00306                 }
00307 
00308                 delete ocbList ;
00309             }
00310         } while (ocbList != NULL);
00311     }
00312     D.Out(pdExcept, "End of the KillFederate Procedure.");
00313 } /* end of killFederate */
00314 
00315 // ----------------------------------------------------------------------------
00317 void
00318 ObjectClassSet::publish(FederateHandle theFederateHandle,
00319                         ObjectClassHandle theClassHandle,
00320                         std::vector <AttributeHandle> &theAttributeList,
00321                         UShort theListSize,
00322                         bool PubOrUnpub)
00323     throw (ObjectClassNotDefined,
00324            AttributeNotDefined,
00325            RTIinternalError,
00326            SecurityError)
00327 {
00328     // It may throw ObjectClassNotDefined
00329     ObjectClass *theClass = getObjectFromHandle(theClassHandle);
00330 
00331     if (PubOrUnpub)
00332         D.Out(pdInit, "Federate %d attempts to publish Object Class %d.",
00333               theFederateHandle, theClassHandle);
00334     else
00335         D.Out(pdTerm, "Federate %d attempts to unpublish Object Class %d.",
00336               theFederateHandle, theClassHandle);
00337 
00338     // It may throw AttributeNotDefined
00339     theClass->publish(theFederateHandle,
00340                       theAttributeList,
00341                       theListSize,
00342                       PubOrUnpub);
00343 }
00344 
00345 // ----------------------------------------------------------------------------
00347 void
00348 ObjectClassSet::registerObjectInstance(FederateHandle the_federate,
00349                                        Object *the_object,
00350                                        ObjectClassHandle the_class)
00351     throw (InvalidObjectHandle,
00352            ObjectClassNotDefined,
00353            ObjectClassNotPublished,
00354            ObjectAlreadyRegistered,
00355            RTIinternalError)
00356 {
00357     ObjectClassHandle currentClass = the_class ;
00358 
00359     // It may throw ObjectClassNotDefined
00360     ObjectClass *theClass = getObjectFromHandle(the_class);
00361 
00362     // It may throw a bunch of exceptions.
00363     ObjectClassBroadcastList *ocbList = NULL ;
00364     ocbList = theClass->registerObjectInstance(the_federate, the_object,
00365                                                the_class);
00366 
00367     // Broadcast DiscoverObject message recursively
00368     if (ocbList != 0) {
00369 
00370         currentClass = theClass->getSuperclass();
00371 
00372         while (currentClass != 0) {
00373             D.Out(pdRegister,
00374                   "Broadcasting Discover msg to parent class "
00375                   "%d for instance %d.",
00376                   currentClass, the_object);
00377             // It may throw ObjectClassNotDefined
00378             theClass = getObjectFromHandle(currentClass);
00379 
00380             theClass->broadcastClassMessage(ocbList);
00381 
00382             currentClass = theClass->getSuperclass();
00383         }
00384 
00385         delete ocbList ;
00386     }
00387 
00388     D[pdRegister] << "Instance " << the_object << " has been registered."
00389                   << endl ;
00390 }
00391 
00392 // ----------------------------------------------------------------------------
00401 void
00402 ObjectClassSet::subscribe(FederateHandle federate,
00403                           ObjectClassHandle class_handle,
00404                           std::vector <AttributeHandle> &attributes,
00405                           int nb,
00406               const RTIRegion *region)
00407     throw (ObjectClassNotDefined, AttributeNotDefined, RTIinternalError,
00408            SecurityError)
00409 {
00410     ObjectClass *object_class = getObjectFromHandle(class_handle);
00411 
00412     bool need_discover = object_class->subscribe(federate, attributes, nb, region);
00413 
00414     if (need_discover)
00415     object_class->recursiveDiscovering(federate, class_handle);
00416 }
00417 
00418 // ----------------------------------------------------------------------------
00420 void
00421 ObjectClassSet::updateAttributeValues(FederateHandle federate,
00422                                       ObjectHandle object_handle,
00423                                       std::vector <AttributeHandle> &attributes,
00424                                       std::vector <AttributeValue_t> &values,
00425                                       UShort nb,
00426                                       FederationTime time,
00427                                       const char *tag)
00428     throw (ObjectNotKnown,
00429            AttributeNotDefined,
00430            AttributeNotOwned,
00431            RTIinternalError,
00432            InvalidObjectHandle)
00433 {
00434     Object *object = getObject(object_handle);
00435     ObjectClass *object_class = getObjectFromHandle(object->getClass());
00436     ObjectClassHandle current_class = object_class->getHandle();
00437 
00438     D.Out(pdProtocol, "Federate %d Updating object %d from class %d.",
00439           federate, object_handle, current_class);
00440 
00441     // It may throw a bunch of exceptions
00442     ObjectClassBroadcastList *ocbList = NULL ;
00443     ocbList = object_class->updateAttributeValues(
00444     federate, object, attributes, values, nb, time, tag);
00445 
00446     // Broadcast ReflectAttributeValues message recursively
00447     current_class = object_class->getSuperclass();
00448 
00449     while (current_class != 0) {
00450         D.Out(pdProtocol,
00451               "Broadcasting RAV msg to parent class %d for instance %d.",
00452               current_class, object_handle);
00453 
00454         // It may throw ObjectClassNotDefined
00455         object_class = getObjectFromHandle(current_class);
00456         object_class->broadcastClassMessage(ocbList, object);
00457 
00458         current_class = object_class->getSuperclass();
00459     }
00460 
00461     delete ocbList ;
00462 }
00463 
00464 // ----------------------------------------------------------------------------
00466 void
00467 ObjectClassSet::updateAttributeValues(FederateHandle federate,
00468                                       ObjectHandle object_handle,
00469                                       std::vector <AttributeHandle> &attributes,
00470                                       std::vector <AttributeValue_t> &values,
00471                                       UShort nb,
00472                                       const char *tag)
00473     throw (ObjectNotKnown,
00474            AttributeNotDefined,
00475            AttributeNotOwned,
00476            RTIinternalError,
00477            InvalidObjectHandle)
00478 {
00479     Object *object = getObject(object_handle);
00480     ObjectClass *object_class = getObjectFromHandle(object->getClass());
00481     ObjectClassHandle current_class = object_class->getHandle();
00482 
00483     D.Out(pdProtocol, "Federate %d Updating object %d from class %d.",
00484           federate, object_handle, current_class);
00485 
00486     // It may throw a bunch of exceptions
00487     ObjectClassBroadcastList *ocbList = NULL ;
00488     ocbList = object_class->updateAttributeValues(
00489     federate, object, attributes, values, nb, tag);
00490 
00491     // Broadcast ReflectAttributeValues message recursively
00492     current_class = object_class->getSuperclass();
00493 
00494     while (current_class != 0) {
00495         D.Out(pdProtocol,
00496               "Broadcasting RAV msg to parent class %d for instance %d.",
00497               current_class, object_handle);
00498 
00499         // It may throw ObjectClassNotDefined
00500         object_class = getObjectFromHandle(current_class);
00501         object_class->broadcastClassMessage(ocbList, object);
00502 
00503         current_class = object_class->getSuperclass();
00504     }
00505 
00506     delete ocbList ;
00507 }
00508 
00509 // ----------------------------------------------------------------------------
00511 void
00512 ObjectClassSet::
00513 negotiatedAttributeOwnershipDivestiture(FederateHandle theFederateHandle,
00514                                         ObjectHandle theObjectHandle,
00515                                         std::vector <AttributeHandle> &theAttributeList,
00516                                         UShort theListSize,
00517                                         const char *theTag)
00518     throw (ObjectNotKnown,
00519            AttributeNotDefined,
00520            AttributeNotOwned,
00521            AttributeAlreadyBeingDivested,
00522            RTIinternalError)
00523 {
00524     // It may throw ObjectNotKnown
00525     ObjectClass *objectClass = getInstanceClass(theObjectHandle);
00526     ObjectClassHandle currentClass = objectClass->getHandle();
00527 
00528     // It may throw a bunch of exceptions.
00529     ObjectClassBroadcastList *ocbList = NULL ;
00530     ocbList =
00531         objectClass->negotiatedAttributeOwnershipDivestiture(theFederateHandle,
00532                                                              theObjectHandle,
00533                                                              theAttributeList,
00534                                                              theListSize,
00535                                                              theTag);
00536 
00537     // Broadcast ReflectAttributeValues message recursively
00538     currentClass = objectClass->getSuperclass();
00539 
00540     while (currentClass != 0) {
00541         D.Out(pdProtocol,
00542               "Broadcasting NAOD msg to parent class %d for instance %d.",
00543               currentClass, theObjectHandle);
00544 
00545         // It may throw ObjectClassNotDefined
00546         objectClass = getObjectFromHandle(currentClass);
00547         objectClass->broadcastClassMessage(ocbList);
00548 
00549         currentClass = objectClass->getSuperclass();
00550     }
00551 
00552     delete ocbList ;
00553 }
00554 
00555 // ----------------------------------------------------------------------------
00557 void
00558 ObjectClassSet::
00559 attributeOwnershipAcquisitionIfAvailable(FederateHandle theFederateHandle,
00560                                          ObjectHandle theObjectHandle,
00561                                          std::vector <AttributeHandle> &theAttributeList,
00562                                          UShort theListSize)
00563     throw (ObjectNotKnown,
00564            ObjectClassNotPublished,
00565            AttributeNotDefined,
00566            AttributeNotPublished,
00567            FederateOwnsAttributes,
00568            AttributeAlreadyBeingAcquired,
00569            RTIinternalError)
00570 {
00571     // It may throw ObjectNotKnown
00572     ObjectClass * objectClass = getInstanceClass(theObjectHandle);
00573 
00574     // It may throw a bunch of exceptions.
00575     objectClass->attributeOwnershipAcquisitionIfAvailable(theFederateHandle,
00576                                                           theObjectHandle,
00577                                                           theAttributeList,
00578                                                           theListSize);
00579 }
00580 
00581 // ----------------------------------------------------------------------------
00583 void
00584 ObjectClassSet::
00585 unconditionalAttributeOwnershipDivestiture(FederateHandle theFederateHandle,
00586                                            ObjectHandle theObjectHandle,
00587                                            std::vector <AttributeHandle> &theAttributeList,
00588                                            UShort theListSize)
00589     throw (ObjectNotKnown,
00590            AttributeNotDefined,
00591            AttributeNotOwned,
00592            RTIinternalError)
00593 {
00594     // It may throw ObjectNotKnown
00595     ObjectClass *objectClass = getInstanceClass(theObjectHandle);
00596     ObjectClassHandle currentClass = objectClass->getHandle();
00597 
00598     // It may throw a bunch of exceptions.
00599     ObjectClassBroadcastList *ocbList = NULL ;
00600     ocbList = objectClass->
00601         unconditionalAttributeOwnershipDivestiture(theFederateHandle,
00602                                                    theObjectHandle,
00603                                                    theAttributeList,
00604                                                    theListSize);
00605 
00606     // Broadcast ReflectAttributeValues message recursively
00607     currentClass = objectClass->getSuperclass();
00608 
00609     while (currentClass != 0) {
00610         D.Out(pdProtocol,
00611               "Broadcasting UAOD msg to parent class %d for instance %d.",
00612               currentClass, theObjectHandle);
00613 
00614         // It may throw ObjectClassNotDefined
00615         objectClass = getObjectFromHandle(currentClass);
00616         objectClass->broadcastClassMessage(ocbList);
00617 
00618         currentClass = objectClass->getSuperclass();
00619     }
00620 
00621     delete ocbList ;
00622 }
00623 
00624 // ----------------------------------------------------------------------------
00626 void
00627 ObjectClassSet::
00628 attributeOwnershipAcquisition(FederateHandle theFederateHandle,
00629                               ObjectHandle theObjectHandle,
00630                               std::vector <AttributeHandle> &theAttributeList,
00631                               UShort theListSize,
00632                               const char *theTag)
00633     throw (ObjectNotKnown,
00634            ObjectClassNotPublished,
00635            AttributeNotDefined,
00636            AttributeNotPublished,
00637            FederateOwnsAttributes,
00638            RTIinternalError)
00639 {
00640     // It may throw ObjectNotKnown
00641     ObjectClass * objectClass = getInstanceClass(theObjectHandle);
00642 
00643     // It may throw a bunch of exceptions.
00644     objectClass->attributeOwnershipAcquisition(theFederateHandle,
00645                                                theObjectHandle,
00646                                                theAttributeList,
00647                                                theListSize,
00648                                                theTag);
00649 }
00650 
00651 // ----------------------------------------------------------------------------
00653 AttributeHandleSet * ObjectClassSet::
00654 attributeOwnershipReleaseResponse(FederateHandle theFederateHandle,
00655                                   ObjectHandle theObjectHandle,
00656                                   std::vector <AttributeHandle> &theAttributeList,
00657                                   UShort theListSize)
00658     throw (ObjectNotKnown,
00659            AttributeNotDefined,
00660            AttributeNotOwned,
00661            FederateWasNotAskedToReleaseAttribute,
00662            RTIinternalError)
00663 {
00664     // It may throw ObjectNotKnown
00665     ObjectClass *objectClass = getInstanceClass(theObjectHandle);
00666 
00667     // It may throw a bunch of exceptions.
00668     return(objectClass->attributeOwnershipReleaseResponse(theFederateHandle,
00669                                                           theObjectHandle,
00670                                                           theAttributeList,
00671                                                           theListSize));
00672 }
00673 
00674 // ----------------------------------------------------------------------------
00676 void ObjectClassSet::
00677 cancelAttributeOwnershipAcquisition(FederateHandle theFederateHandle,
00678                                     ObjectHandle theObjectHandle,
00679                                     std::vector <AttributeHandle> &theAttributeList,
00680                                     UShort theListSize)
00681     throw (ObjectNotKnown,
00682            AttributeNotDefined,
00683            AttributeAlreadyOwned,
00684            AttributeAcquisitionWasNotRequested,
00685            RTIinternalError)
00686 {
00687     // It may throw ObjectNotKnown
00688     ObjectClass *objectClass = getInstanceClass(theObjectHandle);
00689 
00690     // It may throw a bunch of exceptions.
00691     objectClass->cancelAttributeOwnershipAcquisition(theFederateHandle,
00692                                                      theObjectHandle,
00693                                                      theAttributeList,
00694                                                      theListSize);
00695 }
00696 
00697 } // namespace certi
00698 
00699 // $Id: ObjectClassSet.cc,v 3.45 2008/11/08 11:36:05 erk Exp $

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