00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include "certi.hh"
00023
00024 #include "RTItypesImp.hh"
00025 #include "GAV.hh"
00026 #include "PrettyDebug.hh"
00027
00028 #include <algorithm>
00029 #include <string.h>
00030
00031 using namespace certi ;
00032
00033 static PrettyDebug D("LIBRTI", __FILE__);
00034 static PrettyDebug G("GENDOC",__FILE__);
00035
00036
00037
00038 AttributeHandleValuePairSetImp::AttributeHandleValuePairSetImp(ULong size)
00039 {
00040 _order = RECEIVE;
00041 _transport = RELIABLE;
00042
00043 _set.reserve(size);
00044 }
00045
00046 AttributeHandleValuePairSetImp::AttributeHandleValuePairSetImp(const std::vector<AttributeHandleValuePair_t> &val)
00047 : _set(val)
00048 {
00049 _order = RECEIVE;
00050 _transport = RELIABLE;
00051 }
00052
00053 AttributeHandleValuePairSetImp::~AttributeHandleValuePairSetImp()
00054 {
00055 }
00056
00057 ULong AttributeHandleValuePairSetImp::size() const
00058 {
00059 return _set.size();
00060 }
00061
00062 Handle AttributeHandleValuePairSetImp::getHandle(ULong i) const
00063 throw (RTI::ArrayIndexOutOfBounds)
00064 {
00065 if (i < size())
00066 return _set[i].first;
00067 else
00068 throw RTI::ArrayIndexOutOfBounds("");
00069 }
00070
00071 ULong AttributeHandleValuePairSetImp::getValueLength(ULong i) const
00072 throw (RTI::ArrayIndexOutOfBounds)
00073 {
00074 if (i < size())
00075 return _set[i].second.size();
00076 else
00077 throw RTI::ArrayIndexOutOfBounds("");
00078 }
00079
00080 void AttributeHandleValuePairSetImp::getValue(ULong i, char *buff, ULong &len) const
00081 throw (RTI::ArrayIndexOutOfBounds)
00082 {
00083 if (i < size()) {
00084 const AttributeHandleValuePair_t& item = _set[i];
00085 len = item.second.size();
00086 memcpy(buff, item.second.data(), len);
00087 }
00088 else
00089 throw RTI::ArrayIndexOutOfBounds("");
00090 }
00091
00092 char *AttributeHandleValuePairSetImp::getValuePointer(ULong i, ULong &len) const
00093 throw (RTI::ArrayIndexOutOfBounds)
00094 {
00095 if (i < size()) {
00096 const AttributeHandleValuePair_t& item = _set[i];
00097 len = item.second.size();
00098 return (char *)item.second.data();
00099 }
00100 else
00101 throw RTI::ArrayIndexOutOfBounds("");
00102 }
00103
00104 TransportType AttributeHandleValuePairSetImp::getTransportType(ULong) const
00105 throw (RTI::InvalidHandleValuePairSetContext)
00106 {
00107 return _transport;
00108 }
00109
00110 OrderType AttributeHandleValuePairSetImp::getOrderType(ULong) const
00111 throw (RTI::ArrayIndexOutOfBounds, RTI::InvalidHandleValuePairSetContext)
00112 {
00113 return _order;
00114 }
00115
00116 RTI::Region *AttributeHandleValuePairSetImp::getRegion(ULong) const
00117 throw (RTI::ArrayIndexOutOfBounds, RTI::InvalidHandleValuePairSetContext)
00118 {
00119 throw RTI::RTIinternalError("unimplemented function getRegion()");
00120 }
00121
00122 void AttributeHandleValuePairSetImp::add(Handle h, const char *str, ULong len)
00123 throw (RTI::ValueLengthExceeded, RTI::ValueCountExceeded)
00124 {
00125 _set.push_back(AttributeHandleValuePair_t(h, std::string(str, len)));
00126 }
00127
00128 void AttributeHandleValuePairSetImp::remove(Handle h)
00129 throw (RTI::ArrayIndexOutOfBounds)
00130 {
00131 for (std::vector<AttributeHandleValuePair_t>::iterator pos = _set.begin();
00132 pos != _set.end(); pos++) {
00133 if (pos->first == h) {
00134 _set.erase(pos);
00135 return;
00136 }
00137 }
00138
00139 throw RTI::ArrayIndexOutOfBounds("");
00140 }
00141
00142 void AttributeHandleValuePairSetImp::moveFrom(const AttributeHandleValuePairSet &, ULong &)
00143 throw (RTI::ValueCountExceeded, RTI::ArrayIndexOutOfBounds)
00144 {
00145 throw RTI::RTIinternalError("unimplemented function moveFrom()");
00146 }
00147
00148 void AttributeHandleValuePairSetImp::empty()
00149 {
00150 _set.clear();
00151 }
00152
00153 ULong AttributeHandleValuePairSetImp::start() const
00154 {
00155
00156 return 0 ;
00157 }
00158
00159 ULong AttributeHandleValuePairSetImp::valid(ULong i) const
00160 {
00161
00162 return 0 ;
00163 }
00164
00165 ULong AttributeHandleValuePairSetImp::next(ULong i) const
00166 {
00167
00168 return 0 ;
00169 }
00170
00171 const std::vector<AttributeHandleValuePair_t>&
00172 AttributeHandleValuePairSetImp::getAttributeHandleValuePairs() const
00173 {
00174 return _set;
00175 }
00176
00177
00178 AttributeHandleSetImp::AttributeHandleSetImp(ULong size)
00179 {
00180 _set.reserve(size);
00181 }
00182
00183 AttributeHandleSetImp::AttributeHandleSetImp(const std::vector<AttributeHandle> &val)
00184 : _set(val)
00185 {
00186 }
00187
00188 AttributeHandleSetImp::~AttributeHandleSetImp()
00189 {
00190 }
00191
00192 ULong AttributeHandleSetImp::size() const
00193 {
00194 return _set.size();
00195 }
00196
00197 AttributeHandle AttributeHandleSetImp::getHandle(ULong i) const
00198 throw (RTI::ArrayIndexOutOfBounds)
00199 {
00200 if (i < size())
00201 return _set[i];
00202 else
00203 throw RTI::ArrayIndexOutOfBounds("");
00204 }
00205
00206 void AttributeHandleSetImp::add(AttributeHandle h)
00207 throw (RTI::ArrayIndexOutOfBounds, RTI::AttributeNotDefined)
00208 {
00209 _set.push_back(h);
00210 }
00211
00212 void AttributeHandleSetImp::remove(AttributeHandle h)
00213 throw (RTI::AttributeNotDefined)
00214 {
00215 std::vector<AttributeHandle>::iterator pos = std::find(_set.begin(), _set.end(), h);
00216 if (pos != _set.end())
00217 _set.erase(pos);
00218 else
00219 throw RTI::ArrayIndexOutOfBounds("");
00220 }
00221
00222 void AttributeHandleSetImp::empty()
00223 {
00224 _set.clear();
00225 }
00226
00227 RTI::Boolean AttributeHandleSetImp::isEmpty() const
00228 {
00229 return RTI::Boolean(_set.empty());
00230 }
00231
00232 RTI::Boolean AttributeHandleSetImp::isMember(AttributeHandle h) const
00233 {
00234 return RTI::Boolean(std::find(_set.begin(), _set.end(), h) != _set.end());
00235 }
00236
00237 const std::vector<AttributeHandle>&
00238 AttributeHandleSetImp::getAttributeHandles() const
00239 {
00240 return _set;
00241 }
00242
00243
00244 FederateHandleSetImp::FederateHandleSetImp(ULong size)
00245 {
00246 _set.reserve(size);
00247 }
00248
00249 FederateHandleSetImp::~FederateHandleSetImp()
00250 {
00251 }
00252
00253 ULong FederateHandleSetImp::size() const
00254 {
00255 return _set.size();
00256 }
00257
00258 FederateHandle FederateHandleSetImp::getHandle(ULong i) const
00259 throw (RTI::ArrayIndexOutOfBounds)
00260 {
00261 if (i < size())
00262 return _set[i];
00263 else
00264 throw RTI::ArrayIndexOutOfBounds("");
00265 }
00266
00267 void FederateHandleSetImp::add(FederateHandle h)
00268 throw (RTI::ValueCountExceeded)
00269 {
00270 _set.push_back(h);
00271 }
00272
00273 void FederateHandleSetImp::remove(FederateHandle h)
00274 throw (RTI::ArrayIndexOutOfBounds)
00275 {
00276 std::vector<FederateHandle>::iterator pos = std::find(_set.begin(), _set.end(), h);
00277 if (pos != _set.end())
00278 _set.erase(pos);
00279 else
00280 throw RTI::ArrayIndexOutOfBounds("");
00281 }
00282
00283 void FederateHandleSetImp::empty()
00284 {
00285 _set.clear();
00286 }
00287
00288 RTI::Boolean FederateHandleSetImp::isMember(FederateHandle h) const
00289 {
00290 return RTI::Boolean(std::find(_set.begin(), _set.end(), h) != _set.end());
00291 }
00292
00293
00294 ParameterHandleValuePairSetImp::ParameterHandleValuePairSetImp(ULong size)
00295 {
00296 _order = RECEIVE;
00297 _transport = RELIABLE;
00298
00299 _set.reserve(size);
00300 }
00301
00302 ParameterHandleValuePairSetImp::ParameterHandleValuePairSetImp(const std::vector<ParameterHandleValuePair_t> &val)
00303 : _set(val)
00304 {
00305 _order = RECEIVE;
00306 _transport = RELIABLE;
00307 }
00308
00309 ParameterHandleValuePairSetImp::~ParameterHandleValuePairSetImp()
00310 {
00311 }
00312
00313 ULong ParameterHandleValuePairSetImp::size() const
00314 {
00315 return _set.size();
00316 }
00317
00318 Handle ParameterHandleValuePairSetImp::getHandle(ULong i) const
00319 throw (RTI::ArrayIndexOutOfBounds)
00320 {
00321 if (i < size())
00322 return _set[i].first;
00323 else
00324 throw RTI::ArrayIndexOutOfBounds("");
00325 }
00326
00327 ULong ParameterHandleValuePairSetImp::getValueLength(ULong i) const
00328 throw (RTI::ArrayIndexOutOfBounds)
00329 {
00330 if (i < size())
00331 return _set[i].second.size();
00332 else
00333 throw RTI::ArrayIndexOutOfBounds("");
00334 }
00335
00336 void ParameterHandleValuePairSetImp::getValue(ULong i, char *buff, ULong &len) const
00337 throw (RTI::ArrayIndexOutOfBounds)
00338 {
00339 if (i < size()) {
00340 const ParameterHandleValuePair_t& item = _set[i];
00341 len = item.second.size();
00342 memcpy(buff, item.second.data(), len);
00343 }
00344 else
00345 throw RTI::ArrayIndexOutOfBounds("");
00346 }
00347
00348 char *ParameterHandleValuePairSetImp::getValuePointer(ULong i, ULong &len) const
00349 throw (RTI::ArrayIndexOutOfBounds)
00350 {
00351 if (i < size()) {
00352 const ParameterHandleValuePair_t& item = _set[i];
00353 len = item.second.size();
00354 return (char *)item.second.data();
00355 }
00356 else
00357 throw RTI::ArrayIndexOutOfBounds("");
00358 }
00359
00360 TransportType ParameterHandleValuePairSetImp::getTransportType() const
00361 throw (RTI::InvalidHandleValuePairSetContext)
00362 {
00363 return _transport;
00364 }
00365
00366 OrderType ParameterHandleValuePairSetImp::getOrderType() const
00367 throw (RTI::InvalidHandleValuePairSetContext)
00368 {
00369 return _order;
00370 }
00371
00372 RTI::Region *ParameterHandleValuePairSetImp::getRegion() const
00373 throw (RTI::InvalidHandleValuePairSetContext)
00374 {
00375 throw RTI::RTIinternalError("unimplemented function getRegion()");
00376 }
00377
00378 void ParameterHandleValuePairSetImp::add(Handle h, const char *str, ULong len)
00379 throw (RTI::ValueLengthExceeded, RTI::ValueCountExceeded)
00380 {
00381 _set.push_back(ParameterHandleValuePair_t(h, std::string(str, len)));
00382 }
00383
00384 void ParameterHandleValuePairSetImp::remove(Handle h)
00385 throw (RTI::ArrayIndexOutOfBounds)
00386 {
00387 for (std::vector<ParameterHandleValuePair_t>::iterator pos = _set.begin();
00388 pos != _set.end(); pos++) {
00389 if (pos->first == h) {
00390 _set.erase(pos);
00391 return;
00392 }
00393 }
00394
00395 throw RTI::ArrayIndexOutOfBounds("");
00396 }
00397
00398 void ParameterHandleValuePairSetImp::moveFrom(const ParameterHandleValuePairSet &, ULong &)
00399 throw (RTI::ValueCountExceeded, RTI::ArrayIndexOutOfBounds)
00400 {
00401 throw RTI::RTIinternalError("unimplemented function moveFrom()");
00402 }
00403
00404 void ParameterHandleValuePairSetImp::empty()
00405 {
00406 return _set.clear();
00407 }
00408
00409 ULong ParameterHandleValuePairSetImp::start() const
00410 {
00411
00412 return 0;
00413 }
00414
00415 ULong ParameterHandleValuePairSetImp::valid(ULong i) const
00416 {
00417
00418 return 0;
00419 }
00420
00421 ULong ParameterHandleValuePairSetImp::next(ULong i) const
00422 {
00423
00424 return 0;
00425 }
00426
00427 const std::vector<ParameterHandleValuePair_t> &
00428 ParameterHandleValuePairSetImp::getParameterHandleValuePairs() const
00429 {
00430 return _set;
00431 }
00432
00433
00434 RTI::AttributeHandleValuePairSet *
00435 RTI::AttributeSetFactory::create(ULong size)
00436 throw (MemoryExhausted, ValueCountExceeded, HandleValuePairMaximumExceeded)
00437 {
00438 return new AttributeHandleValuePairSetImp(size);
00439 }
00440
00441
00442 RTI::AttributeHandleSet *
00443 RTI::AttributeHandleSetFactory::create(ULong size)
00444 throw (MemoryExhausted, ValueCountExceeded)
00445 {
00446 return new AttributeHandleSetImp(size);
00447 }
00448
00449
00450 RTI::FederateHandleSet *
00451 RTI::FederateHandleSetFactory::create(ULong size)
00452 throw (MemoryExhausted, ValueCountExceeded)
00453 {
00454 return new FederateHandleSetImp(size);
00455 }
00456
00457
00458 RTI::ParameterHandleValuePairSet *
00459 RTI::ParameterSetFactory::create(ULong size)
00460 throw (MemoryExhausted, ValueCountExceeded, HandleValuePairMaximumExceeded)
00461 {
00462 return new ParameterHandleValuePairSetImp(size);
00463 }
00464
00465
00466 RegionImp::RegionImp(RegionHandle h, SpaceHandle s, const std::vector<Extent> &ext)
00467 : handle(h), space(s), coExtents(ext)
00468 {
00469 }
00470
00471 RegionImp::~RegionImp()
00472 {
00473 }
00474
00475 ULong RegionImp::getRangeLowerBound(ExtentIndex index, DimensionHandle dimension) const
00476 throw (RTI::ArrayIndexOutOfBounds)
00477 {
00478 if (index < extents.size())
00479 return extents[index].getRangeLowerBound(dimension);
00480 else
00481 throw RTI::ArrayIndexOutOfBounds("Extent index above limit");
00482 }
00483
00484 ULong RegionImp::getRangeUpperBound(ExtentIndex index, DimensionHandle dimension) const
00485 throw (RTI::ArrayIndexOutOfBounds)
00486 {
00487 if (index < extents.size())
00488 return extents[index].getRangeUpperBound(dimension);
00489 else
00490 throw RTI::ArrayIndexOutOfBounds("Extent index above limit");
00491 }
00492
00493 void RegionImp::setRangeLowerBound(ExtentIndex index, DimensionHandle dimension, ULong val)
00494 throw (RTI::ArrayIndexOutOfBounds)
00495 {
00496 if (index < extents.size())
00497 extents[index].setRangeLowerBound(dimension, val);
00498 else
00499 throw RTI::ArrayIndexOutOfBounds("Extent index above limit");
00500 }
00501
00502 void RegionImp::setRangeUpperBound(ExtentIndex index, DimensionHandle dimension, ULong val)
00503 throw (RTI::ArrayIndexOutOfBounds)
00504 {
00505 if (index < extents.size())
00506 extents[index].setRangeUpperBound(dimension, val);
00507 else
00508 throw RTI::ArrayIndexOutOfBounds("Extent index above limit");
00509 }
00510
00511 SpaceHandle RegionImp::getSpaceHandle() const
00512 throw ()
00513 {
00514 return space;
00515 }
00516
00517 ULong RegionImp::getNumberOfExtents() const
00518 throw ()
00519 {
00520 return coExtents.size();
00521 }
00522
00523 ULong RegionImp::getRangeLowerBoundNotificationLimit(ExtentIndex index, DimensionHandle dimension) const
00524 throw (RTI::ArrayIndexOutOfBounds)
00525 {
00526 if (index < coExtents.size())
00527 return coExtents[index].getRangeLowerBound(dimension);
00528 else
00529 throw RTI::ArrayIndexOutOfBounds("Extent index above limit");
00530 }
00531
00532 ULong RegionImp::getRangeUpperBoundNotificationLimit(ExtentIndex index, DimensionHandle dimension) const
00533 throw (RTI::ArrayIndexOutOfBounds)
00534 {
00535 if (index < coExtents.size())
00536 return coExtents[index].getRangeUpperBound(dimension);
00537 else
00538 throw RTI::ArrayIndexOutOfBounds("Extent index above limit");
00539 }
00540
00541