RTIfedTime.cc

Go to the documentation of this file.
00001 // ----------------------------------------------------------------------------
00002 // CERTI - HLA RunTime Infrastructure
00003 // Copyright (C) 2002-2006  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 USA
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     //throw RTI::InvalidFederationTime("Could not cast to RTIfedTime");
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 } // anonymous namespace
00062 
00063 // ----------------------------------------------------------------------------
00064 // FedTimeFactory
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         //throw RTI::MemoryExhausted("Cannot allocate RTI::FedTime.");
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         //throw RTI::MemoryExhausted("Cannot allocate RTI::FedTime.");
00086     }
00087 }
00088 
00089 // ----------------------------------------------------------------------------
00090 // RTIfedTime
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     // current implementation of RTIfedtime takes
00162     // four IEEE-754 double values.
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 }

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