00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #include <config.h>
00025 #include "DataDistribution.hh"
00026
00027 #include "Interaction.hh"
00028 #include "InteractionSet.hh"
00029 #include "Object.hh"
00030 #include "ObjectAttribute.hh"
00031 #include "ObjectClass.hh"
00032 #include "ObjectClassSet.hh"
00033 #include "ObjectClassAttribute.hh"
00034 #include "RoutingSpace.hh"
00035 #include "FedRegion.hh"
00036 #include "NM_Classes.hh"
00037
00038 #include <cassert>
00039 #include <memory>
00040
00041 using std::string ;
00042 using std::endl ;
00043
00044 namespace certi {
00045 namespace rtia {
00046
00047 static pdCDebug D("RTIA_DDM", __FILE__);
00048
00049
00050 DataDistribution::DataDistribution(RootObject *root_object,
00051 FederationManagement *fed_management,
00052 Communications *communications)
00053 : rootObject(root_object),
00054 fm(fed_management),
00055 comm(communications) { }
00056
00057
00058 SpaceHandle
00059 DataDistribution::getRoutingSpaceHandle(std::string name) const
00060 {
00061 return rootObject->getRoutingSpaceHandle(name);
00062 }
00063
00064
00065
00066
00067 string
00068 DataDistribution::getRoutingSpaceName(SpaceHandle handle) const
00069 {
00070 return rootObject->getRoutingSpaceName(handle);
00071 }
00072
00073
00074
00075
00076 DimensionHandle
00077 DataDistribution::getDimensionHandle(std::string dimension, SpaceHandle space) const
00078 throw (SpaceNotDefined, NameNotFound)
00079 {
00080 return rootObject->getRoutingSpace(space).getDimensionHandle(dimension);
00081 }
00082
00083
00084
00085
00086 string
00087 DataDistribution::getDimensionName(DimensionHandle dimension,
00088 SpaceHandle space) const
00089 throw (SpaceNotDefined, DimensionNotDefined)
00090 {
00091 return rootObject->getRoutingSpace(space).getDimensionName(dimension);
00092 }
00093
00094
00095
00096
00097 SpaceHandle
00098 DataDistribution::getAttributeSpace(AttributeHandle attribute,
00099 ObjectClassHandle object_class) const
00100 throw (ObjectClassNotDefined, AttributeNotDefined)
00101 {
00102 std::cout<<"DataDistribution::getAttributeSpace"<<std::endl;
00103 return rootObject->ObjectClasses->getObjectFromHandle(object_class)->
00104 getAttribute(attribute)->getSpace();
00105 }
00106
00107
00108
00109
00110 SpaceHandle
00111 DataDistribution::getInteractionSpace(InteractionClassHandle interaction) const
00112 throw (InteractionClassNotDefined)
00113 {
00114 return rootObject->Interactions->getObjectFromHandle(interaction)->getSpace();
00115 }
00116
00117
00118
00119
00120 long
00121 DataDistribution::createRegion(SpaceHandle space,
00122 unsigned long nb_extents,
00123 TypeException &e)
00124 throw (SpaceNotDefined)
00125 {
00126 D[pdDebug] << "Start creating region in space " << space << "..." << endl ;
00127 NM_DDM_Create_Region req;
00128
00129 req.federation = fm->_numero_federation ;
00130 req.federate = fm->federate ;
00131 req.space = space ;
00132 req.nbExtents = nb_extents ;
00133
00134 comm->sendMessage(&req);
00135 std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::DDM_CREATE_REGION, req.federate));
00136 e = rep->exception ;
00137
00138 if (e == e_NO_EXCEPTION) {
00139 D[pdDebug] << "Create region " << rep->region << endl ;
00140 RTIRegion *region = new RTIRegion(rep->region,
00141 rootObject->getRoutingSpace(space),
00142 nb_extents);
00143
00144 assert(region->getNumberOfExtents() == nb_extents);
00145 rootObject->addRegion(region);
00146 return rep->region;
00147 }
00148 else {
00149 return 0 ;
00150 }
00151 }
00152
00153
00154
00155
00156 void
00157 DataDistribution::modifyRegion(RegionHandle handle,
00158 const std::vector<Extent> &extents,
00159 TypeException &e)
00160 {
00161 D[pdDebug] << "Modify region " << handle << "..." << endl ;
00162
00163
00164 RTIRegion *region = rootObject->getRegion(handle);
00165
00166
00167 NM_DDM_Modify_Region req;
00168
00169 req.federation = fm->_numero_federation ;
00170 req.federate = fm->federate ;
00171 req.region = handle ;
00172 req.setExtents(extents);
00173
00174 comm->sendMessage(&req);
00175 std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::DDM_MODIFY_REGION, req.federate));
00176 e = rep->exception ;
00177
00178 if (e == e_NO_EXCEPTION) {
00179 region->replaceExtents(extents);
00180 D[pdDebug] << "Modified region " << handle << endl ;
00181 }
00182 }
00183
00184
00185
00186
00187 void
00188 DataDistribution::deleteRegion(long handle, TypeException &e)
00189 throw (RegionNotKnown, RegionInUse)
00190 {
00191 D[pdDebug] << "Delete region " << handle << "..." << endl ;
00192
00193
00194 rootObject->getRegion(handle);
00195
00196
00197 NM_DDM_Delete_Region req;
00198
00199 req.federation = fm->_numero_federation ;
00200 req.federate = fm->federate ;
00201 req.region = handle ;
00202
00203 comm->sendMessage(&req);
00204 std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::DDM_DELETE_REGION, req.federate));
00205 e = rep->exception ;
00206
00207 if (e == e_NO_EXCEPTION) {
00208 rootObject->deleteRegion(handle);
00209 D[pdDebug] << "Deleted region " << handle << endl ;
00210 }
00211 }
00212
00213
00214 void
00215 DataDistribution::associateRegion(ObjectHandle object,
00216 RegionHandle region,
00217 std::vector <AttributeHandle> &attr,
00218 int nb,
00219 TypeException &e)
00220 throw (RegionNotKnown)
00221 {
00222 D[pdDebug] << "Associate Region " << region << std::endl ;
00223
00224 RTIRegion *r = rootObject->getRegion(region);
00225
00226 D[pdDebug] << "- unassociate object " << object << std::endl ;
00227 rootObject->getObject(object)->unassociate(r);
00228 for (int i = 0 ; i < nb ; ++i) {
00229 D[pdDebug] << "- associate attribute " << attr[i] << std::endl ;
00230 rootObject->getObjectAttribute(object, attr[i])->associate(r);
00231 }
00232
00233 NM_DDM_Associate_Region req;
00234
00235 req.federation = fm->_numero_federation ;
00236 req.federate = fm->federate ;
00237 req.object = object ;
00238 req.region = region ;
00239
00240 req.setAHS(attr, nb);
00241
00242 comm->sendMessage(&req);
00243 std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::DDM_ASSOCIATE_REGION,req.federate));
00244
00245 e = rep->exception ;
00246
00247 }
00248
00249
00250 ObjectHandle
00251 DataDistribution::registerObject(ObjectClassHandle class_handle,
00252 const std::string name,
00253 const std::vector <AttributeHandle> &attrs,
00254 int nb,
00255 const std::vector<RegionHandle> regions,
00256 TypeException &e)
00257 {
00258 D[pdDebug] << "Register object of class " << class_handle << " with "
00259 << regions.size() << " region(s)." << std::endl ;
00260
00261 NM_DDM_Register_Object req;
00262
00263 req.federation = fm->_numero_federation ;
00264 req.federate = fm->federate ;
00265 req.objectClass = class_handle ;
00266 req.setTag(name.c_str());
00267 req.setAHS(attrs, nb);
00268 req.setRegions(regions);
00269
00270 comm->sendMessage(&req);
00271 std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::DDM_REGISTER_OBJECT,req.federate));
00272
00273 e = rep->exception ;
00274
00275 if (e == e_NO_EXCEPTION) {
00276 rootObject->registerObjectInstance(fm->federate, class_handle, rep->object,
00277 rep->getLabel().c_str());
00278 for (int i = 0 ; i < nb ; ++i) {
00279 D[pdDebug] << "Register attribute [" << i << "] Attr: " << attrs[i]
00280 << " Region: " << regions[i] << std::endl ;
00281
00282 ObjectAttribute *attribute = rootObject->getObjectAttribute(rep->object, attrs[i]);
00283 RTIRegion *region = rootObject->getRegion(regions[i]);
00284 attribute->associate(region);
00285 }
00286 return rep->object;
00287 }
00288 else return 0 ;
00289 }
00290
00291
00292 void
00293 DataDistribution::unassociateRegion(ObjectHandle object,
00294 RegionHandle region,
00295 TypeException &e)
00296 throw (ObjectNotKnown, InvalidRegionContext, RegionNotKnown)
00297 {
00298 D[pdDebug] << "Unassociate Region " << region << std::endl ;
00299
00300 RTIRegion *r = rootObject->getRegion(region);
00301
00302 rootObject->getObject(object)->unassociate(r);
00303
00304 NM_DDM_Unassociate_Region req;
00305
00306 req.federation = fm->_numero_federation ;
00307 req.federate = fm->federate ;
00308 req.object = object ;
00309 req.region = region ;
00310
00311 comm->sendMessage(&req);
00312 std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::DDM_UNASSOCIATE_REGION,
00313 req.federate));
00314
00315 e = rep->exception ;
00316 }
00317
00318
00319 void
00320 DataDistribution::subscribe(ObjectClassHandle obj_class,
00321 RegionHandle region,
00322 std::vector <AttributeHandle> &attr,
00323 int nb,
00324 TypeException &e)
00325 throw (RegionNotKnown)
00326 {
00327 D[pdDebug] << "Subscribe attributes with region " << region << endl ;
00328 rootObject->getRegion(region);
00329
00330 NM_DDM_Subscribe_Attributes req;
00331
00332 req.federation = fm->_numero_federation ;
00333 req.federate = fm->federate ;
00334 req.objectClass = obj_class ;
00335 req.region = region ;
00336 req.setAHS(attr, nb);
00337
00338 comm->sendMessage(&req);
00339 std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::DDM_SUBSCRIBE_ATTRIBUTES,
00340 req.federate));
00341
00342 e = rep->exception ;
00343 }
00344
00345
00346 void
00347 DataDistribution::unsubscribeAttributes(ObjectClassHandle obj_class,
00348 RegionHandle region,
00349 TypeException &e)
00350 throw (RegionNotKnown)
00351 {
00352 D[pdDebug] << "Unsubscribe class " << obj_class
00353 << " with region " << region << endl ;
00354 rootObject->getRegion(region);
00355
00356 NM_DDM_Unsubscribe_Attributes req;
00357
00358 req.federation = fm->_numero_federation ;
00359 req.federate = fm->federate ;
00360 req.objectClass = obj_class ;
00361 req.region = region ;
00362
00363 comm->sendMessage(&req);
00364 std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::DDM_UNSUBSCRIBE_ATTRIBUTES,
00365 req.federate));
00366
00367 e = rep->exception ;
00368 }
00369
00370
00371 void
00372 DataDistribution::subscribeInteraction(InteractionClassHandle int_class,
00373 RegionHandle region,
00374 TypeException &e)
00375 throw (RegionNotKnown)
00376 {
00377 D[pdDebug] << "Subscribe interaction with region " << region << endl ;
00378 rootObject->getRegion(region);
00379
00380 NM_DDM_Subscribe_Interaction req;
00381
00382 req.interactionClass = int_class ;
00383 req.region = region ;
00384
00385 comm->sendMessage(&req);
00386 std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::DDM_SUBSCRIBE_INTERACTION,
00387 req.federate));
00388
00389 e = rep->exception ;
00390 }
00391
00392
00393 void
00394 DataDistribution::unsubscribeInteraction(InteractionClassHandle int_class,
00395 RegionHandle region,
00396 TypeException &e)
00397 throw (RegionNotKnown)
00398 {
00399 D[pdDebug] << "Unsubscribe interaction with region " << region << endl ;
00400 rootObject->getRegion(region);
00401
00402 NM_DDM_Unsubscribe_Interaction req;
00403
00404 req.interactionClass = int_class ;
00405 req.region = region ;
00406
00407 comm->sendMessage(&req);
00408 std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::DDM_UNSUBSCRIBE_INTERACTION,
00409 req.federate));
00410
00411 e = rep->exception ;
00412 }
00413
00414 }}
00415
00416