00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include <math.h>
00023
00024 #include "certi.hh"
00025 #include "fedtime.hh"
00026 #include "FedTimeD.hh"
00027
00028 #include <algorithm>
00029 #include <limits>
00030 #include <sstream>
00031 #include <typeinfo>
00032
00033 using std::stringstream ;
00034
00035 namespace
00036 {
00037
00038
00041 inline const RTIfedTime &
00042 rft(const RTI::FedTime &time)
00043 throw (RTI::InvalidFederationTime)
00044 {
00045 try {
00046 return dynamic_cast<const RTIfedTime &>(time);
00047 }
00048 catch (std::bad_cast) {
00049
00050 }
00051 }
00052
00053 inline bool
00054 is_infinity(const RTI::FedTime &time)
00055 {
00056 return const_cast<RTI::FedTime &>(time).isPositiveInfinity() == RTI::RTI_TRUE ;
00057 }
00058
00059 const char *infinity_str = "+inf" ;
00060
00061 }
00062
00063
00064
00065 RTI::FedTime *
00066 RTI::FedTimeFactory::makeZero()
00067 throw (RTI::MemoryExhausted)
00068 {
00069 try {
00070 return new RTIfedTime();
00071 }
00072 catch (std::bad_alloc) {
00073
00074 }
00075 }
00076
00077 RTI::FedTime *
00078 RTI::FedTimeFactory::decode(const char *buf)
00079 throw (RTI::MemoryExhausted)
00080 {
00081 try {
00082 return new RTIfedTime(*(const RTI::Double*)buf);
00083 }
00084 catch (std::bad_alloc) {
00085
00086 }
00087 }
00088
00089
00090
00091 RTIfedTime::RTIfedTime()
00092 : _fedTime(0),
00093 _zero(0),
00094 _epsilon(std::numeric_limits<double>::epsilon()),
00095 _positiveInfinity(std::numeric_limits<double>::infinity()) { }
00096
00097 RTIfedTime::RTIfedTime(const RTI::Double &time)
00098 : _fedTime(time),
00099 _zero(0),
00100 _epsilon(std::numeric_limits<double>::epsilon()),
00101 _positiveInfinity(std::numeric_limits<double>::infinity()) { }
00102
00103 RTIfedTime::RTIfedTime(const RTI::FedTime &time)
00104 : _fedTime(rft(time).getTime()),
00105 _zero(0),
00106 _epsilon(std::numeric_limits<double>::epsilon()),
00107 _positiveInfinity(std::numeric_limits<double>::infinity()) { }
00108
00109
00110 RTIfedTime::RTIfedTime(const RTIfedTime &time)
00111 : FedTime(),
00112 _fedTime(time._fedTime),
00113 _zero(time._zero),
00114 _epsilon(time._epsilon),
00115 _positiveInfinity(time._positiveInfinity) { }
00116
00117
00118 RTIfedTime::~RTIfedTime()
00119 {
00120 }
00121
00122
00123 void
00124 RTIfedTime::setZero()
00125 {
00126 _fedTime = _zero;
00127 }
00128
00129
00130 RTI::Boolean
00131 RTIfedTime::isZero()
00132 {
00133 return RTI::Boolean(_fedTime == _zero);
00134 }
00135
00136
00137 void
00138 RTIfedTime::setEpsilon()
00139 {
00140 _fedTime = _epsilon;
00141 }
00142
00143
00144 void
00145 RTIfedTime::setPositiveInfinity()
00146 {
00147 _fedTime = _positiveInfinity;
00148 }
00149
00150
00151 RTI::Boolean
00152 RTIfedTime::isPositiveInfinity()
00153 {
00154 return RTI::Boolean(_fedTime == _positiveInfinity);
00155 }
00156
00157
00158 int
00159 RTIfedTime::encodedLength() const
00160 {
00161
00162
00163 return (sizeof(_fedTime)+
00164 sizeof(_zero)+
00165 sizeof(_epsilon)+
00166 sizeof(_positiveInfinity));
00167 }
00168
00169
00170 void
00171 RTIfedTime::encode(char *buffer) const
00172 {
00173 memcpy(buffer, &_fedTime, sizeof(RTI::Double));
00174 }
00175
00176
00177 int
00178 RTIfedTime::getPrintableLength() const
00179 {
00180 stringstream s ;
00181
00182 if (is_infinity(*this))
00183 s << infinity_str ;
00184 else
00185 s << _fedTime ;
00186
00187 return s.str().length() + 1 ;
00188 }
00189
00190
00191 void
00192 RTIfedTime::getPrintableString(char *str)
00193 {
00194 stringstream s ;
00195
00196 if (is_infinity(*this))
00197 s << infinity_str ;
00198 else
00199 s << _fedTime ;
00200
00201 s >> str ;
00202 str[s.str().length()] = 0 ;
00203 }
00204
00205
00206 RTI::FedTime &
00207 RTIfedTime::operator+=(const RTI::FedTime &time)
00208 throw (RTI::InvalidFederationTime)
00209 {
00210 _fedTime += rft(time)._fedTime ;
00211 return *this;
00212 }
00213
00214
00215 RTI::FedTime &
00216 RTIfedTime::operator-=(const RTI::FedTime &time)
00217 throw (RTI::InvalidFederationTime)
00218 {
00219 _fedTime -= rft(time)._fedTime ;
00220 return *this;
00221 }
00222
00223
00224 RTI::Boolean
00225 RTIfedTime::operator<=(const RTI::FedTime &time) const
00226 throw (RTI::InvalidFederationTime)
00227 {
00228 if (const_cast<RTI::FedTime &>(time).isPositiveInfinity())
00229 return RTI::RTI_TRUE ;
00230 else if (is_infinity(*this))
00231 return RTI::RTI_FALSE ;
00232 else
00233 return RTI::Boolean(certi::fcmp(_fedTime, rft(time)._fedTime, _epsilon) <= 0);
00234 }
00235
00236
00237 RTI::Boolean
00238 RTIfedTime::operator<(const RTI::FedTime &time) const
00239 throw (RTI::InvalidFederationTime)
00240 {
00241 if (is_infinity(*this))
00242 return RTI::RTI_FALSE ;
00243 else
00244 return RTI::Boolean(is_infinity(time) || certi::fcmp(_fedTime, rft(time)._fedTime, _epsilon) < 0);
00245 }
00246
00247
00248 RTI::Boolean
00249 RTIfedTime::operator>=(const RTI::FedTime &time) const
00250 throw (RTI::InvalidFederationTime)
00251 {
00252 if (is_infinity(*this))
00253 return RTI::RTI_TRUE ;
00254 else if (is_infinity(time))
00255 return RTI::RTI_FALSE ;
00256 else
00257 return RTI::Boolean(certi::fcmp(_fedTime, rft(time)._fedTime, _epsilon) >= 0);
00258 }
00259
00260
00261 RTI::Boolean
00262 RTIfedTime::operator>(const RTI::FedTime &time) const
00263 throw (RTI::InvalidFederationTime)
00264 {
00265 if (is_infinity(time))
00266 return RTI::RTI_FALSE ;
00267 else
00268 return RTI::Boolean(is_infinity(*this) || certi::fcmp(_fedTime, rft(time)._fedTime, _epsilon) > 0);
00269 }
00270
00271
00272 inline RTI::Boolean
00273 RTIfedTime::operator==(const RTI::FedTime &time) const
00274 throw (RTI::InvalidFederationTime)
00275 {
00276 if (is_infinity(*this) && is_infinity(time))
00277 return RTI::RTI_TRUE ;
00278 else if (is_infinity(*this) || is_infinity(time))
00279 return RTI::RTI_FALSE ;
00280 else
00281 return RTI::Boolean(certi::fcmp(_fedTime, rft(time)._fedTime, _epsilon) == 0);
00282 }
00283
00284
00285 RTI::FedTime &
00286 RTIfedTime::operator=(const RTI::FedTime &time)
00287 throw (RTI::InvalidFederationTime)
00288 {
00289 _fedTime = rft(time)._fedTime ;
00290 return *this ;
00291 }
00292
00293
00294 RTI::Double
00295 RTIfedTime::getTime() const
00296 {
00297 return _fedTime ;
00298 }
00299
00300
00301 RTI::Boolean
00302 RTIfedTime::operator==(const RTI::Double &time) const
00303 throw (RTI::InvalidFederationTime)
00304 {
00305 return RTI::Boolean(!is_infinity(*this) && certi::fcmp(_fedTime, time, _epsilon) == 0);
00306 }
00307
00308
00309 RTI::Boolean
00310 RTIfedTime::operator!=(const RTI::FedTime &time) const
00311 throw (RTI::InvalidFederationTime)
00312 {
00313 return RTI::Boolean(certi::fcmp(_fedTime, rft(time)._fedTime, _epsilon) != 0);
00314 }
00315
00316
00317 RTI::Boolean
00318 RTIfedTime::operator!=(const RTI::Double &time) const
00319 throw (RTI::InvalidFederationTime)
00320 {
00321 return RTI::Boolean(is_infinity(*this) || certi::fcmp(_fedTime, time, _epsilon) != 0);
00322 }
00323
00324
00325 RTI::FedTime &
00326 RTIfedTime::operator=(const RTIfedTime &time)
00327 throw (RTI::InvalidFederationTime)
00328 {
00329 _fedTime = time._fedTime ;
00330 return *this ;
00331 }
00332
00333
00334 RTI::FedTime &
00335 RTIfedTime::operator=(const RTI::Double &time)
00336 throw (RTI::InvalidFederationTime)
00337 {
00338 _fedTime = time ;
00339 return *this ;
00340 }
00341
00342 RTI::FedTime &
00343 RTIfedTime::operator*=(const RTI::FedTime &time)
00344 throw (RTI::InvalidFederationTime)
00345 {
00346 _fedTime *= rft(time)._fedTime ;
00347 return *this ;
00348 }
00349
00350 RTI::FedTime &
00351 RTIfedTime::operator/=(const RTI::FedTime &time)
00352 throw (RTI::InvalidFederationTime)
00353 {
00354 _fedTime /= rft(time)._fedTime ;
00355 return *this ;
00356 }
00357
00358 RTI::FedTime &
00359 RTIfedTime::operator+=(const RTI::Double &time)
00360 throw (RTI::InvalidFederationTime)
00361 {
00362 _fedTime += time ;
00363 return *this ;
00364 }
00365
00366 RTI::FedTime &
00367 RTIfedTime::operator-=(const RTI::Double &time)
00368 throw (RTI::InvalidFederationTime)
00369 {
00370 _fedTime -= time ;
00371 return *this ;
00372 }
00373
00374 RTI::FedTime &
00375 RTIfedTime::operator*=(const RTI::Double &time)
00376 throw (RTI::InvalidFederationTime)
00377 {
00378 _fedTime *= time ;
00379 return *this ;
00380 }
00381
00382 RTI::FedTime &
00383 RTIfedTime::operator/=(const RTI::Double &time)
00384 throw (RTI::InvalidFederationTime)
00385 {
00386 _fedTime /= time ;
00387 return *this ;
00388 }
00389
00390
00391 RTIfedTime
00392 RTIfedTime::operator+(const RTI::FedTime &time)
00393 throw (RTI::InvalidFederationTime)
00394 {
00395 RTIfedTime fedtime = _fedTime + rft(time)._fedTime ;
00396 return fedtime ;
00397 }
00398
00399 RTIfedTime
00400 RTIfedTime::operator+(const RTI::Double &time)
00401 throw (RTI::InvalidFederationTime)
00402 {
00403 RTIfedTime fedtime = _fedTime + time ;
00404 return fedtime ;
00405 }
00406
00407
00408 RTIfedTime
00409 RTIfedTime::operator-(const RTI::FedTime &time)
00410 throw (RTI::InvalidFederationTime)
00411 {
00412 RTIfedTime fedtime = _fedTime - rft(time)._fedTime ;
00413 return fedtime ;
00414 }
00415
00416 RTIfedTime
00417 RTIfedTime::operator-(const RTI::Double &time)
00418 throw (RTI::InvalidFederationTime)
00419 {
00420 RTIfedTime fedtime = _fedTime - time ;
00421 return fedtime ;
00422 }
00423
00424
00425 RTIfedTime
00426 RTIfedTime::operator*(const RTI::FedTime &time)
00427 throw (RTI::InvalidFederationTime)
00428 {
00429 RTIfedTime fedtime = _fedTime * rft(time)._fedTime ;
00430 return fedtime ;
00431 }
00432
00433 RTIfedTime
00434 RTIfedTime::operator*(const RTI::Double &time)
00435 throw (RTI::InvalidFederationTime)
00436 {
00437 RTIfedTime fedtime = _fedTime * time ;
00438 return fedtime ;
00439 }
00440
00441
00442 RTIfedTime
00443 RTIfedTime::operator/(const RTI::FedTime &time)
00444 throw (RTI::InvalidFederationTime)
00445 {
00446 RTIfedTime fedtime = _fedTime / rft(time)._fedTime ;
00447 return fedtime ;
00448 }
00449
00450 RTIfedTime
00451 RTIfedTime::operator/(const RTI::Double &time)
00452 throw (RTI::InvalidFederationTime)
00453 {
00454 RTIfedTime fedtime = _fedTime / time ;
00455 return fedtime ;
00456 }
00457
00458
00459 std::ostream &
00460 operator<<(std::ostream &s, const RTI::FedTime &time)
00461 {
00462 if (is_infinity(time))
00463 s << infinity_str ;
00464 else
00465 s << rft(time).getTime();
00466 return s ;
00467 }
00468
00469
00470
00471
00472 RTIfedTime
00473 operator+(const RTI::Double &d, const RTI::FedTime &time)
00474 {
00475 RTIfedTime fedtime = d + rft(time).getTime();
00476 return fedtime ;
00477 }
00478
00479
00480 RTIfedTime
00481 operator-(const RTI::Double &d, const RTI::FedTime &time)
00482 {
00483 RTIfedTime fedtime = d - rft(time).getTime();
00484 return fedtime ;
00485 }
00486
00487
00488 RTIfedTime
00489 operator*(const RTI::Double &d, const RTI::FedTime &time)
00490 {
00491 RTIfedTime fedtime = d * rft(time).getTime();
00492 return fedtime ;
00493 }
00494
00495
00496 RTIfedTime
00497 operator/(const RTI::Double &d, const RTI::FedTime &time)
00498 {
00499 RTIfedTime fedtime = d / rft(time).getTime();
00500 return fedtime ;
00501 }