FedTime.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 // $Id: FedTime.cc,v 3.16 2009/04/02 19:58:09 erk Exp $
00022 // ----------------------------------------------------------------------------
00023 
00024 #include <math.h>
00025 
00026 #include "FedTimeD.hh"
00027 
00028 #include <limits>
00029 #include <sstream>
00030 
00031 using namespace certi;
00032 
00033 namespace
00034 {
00035 
00036 const char *infinity_str = "+inf" ;
00037 
00038 } // anonymous namespace
00039 
00040 // ----------------------------------------------------------------------------
00041 // FedTime
00042 
00043 const double FedTime::epsilon = std::numeric_limits<double>::epsilon();
00044 
00045 int
00046 FedTime::fcmp(const double x1, const double x2) {
00047     return certi::fcmp(x1,x2,FedTime::epsilon);
00048 }
00049 
00050 // ----------------------------------------------------------------------------
00051 // FedTime
00052 FedTime::FedTime()
00053     : _fedTime(0),
00054       _zero(0),
00055       _epsilon(FedTime::epsilon),
00056       _positiveInfinity(std::numeric_limits<double>::infinity()) { }
00057 
00058 FedTime::FedTime(const double &time)
00059     : _fedTime(time),
00060       _zero(0),
00061       _epsilon(FedTime::epsilon),
00062       _positiveInfinity(std::numeric_limits<double>::infinity()) { }
00063 
00064 FedTime::FedTime(const FedTime &time)
00065     : _fedTime(time._fedTime),
00066       _zero(time._zero),
00067       _epsilon(time._epsilon),
00068       _positiveInfinity(time._positiveInfinity) { }
00069 
00070 // ----------------------------------------------------------------------------
00071 FedTime::~FedTime()
00072 {
00073 }
00074 
00075 // ----------------------------------------------------------------------------
00076 void
00077 FedTime::setZero()
00078 {
00079     _fedTime = _zero;
00080 }
00081 
00082 // ----------------------------------------------------------------------------
00083 bool
00084 FedTime::isZero()
00085 {
00086     return bool(_fedTime == _zero);
00087 }
00088 
00089 // ----------------------------------------------------------------------------
00090 void
00091 FedTime::setEpsilon()
00092 {
00093     _fedTime = _epsilon;
00094 }
00095 
00096 // ----------------------------------------------------------------------------
00097 void
00098 FedTime::setPositiveInfinity()
00099 {
00100     _fedTime = _positiveInfinity;
00101 }
00102 
00103 // ----------------------------------------------------------------------------
00104 bool
00105 FedTime::isPositiveInfinity() const
00106 {
00107     return bool(_fedTime == _positiveInfinity);
00108 }
00109 
00110 // ----------------------------------------------------------------------------
00111 int
00112 FedTime::encodedLength() const
00113 {
00114     // current implementation of FedTime takes
00115     // four IEEE-754 double values.
00116     return (sizeof(_fedTime)+
00117             sizeof(_zero)+
00118             sizeof(_epsilon)+
00119             sizeof(_positiveInfinity));
00120 }
00121 
00122 // ----------------------------------------------------------------------------
00123 void
00124 FedTime::encode(char *buffer) const
00125 {
00126 //  libhla::HLAfloat64LE encoded_fedTime;
00127 //  encoded_fedTime = _fedTime;
00128 //  strncpy(buffer,(char*)&(encoded_fedTime),encoded_fedTime.__sizeof());
00129 }
00130 
00131 // ----------------------------------------------------------------------------
00132 int
00133 FedTime::getPrintableLength() const
00134 {
00135     std::stringstream s ;
00136 
00137     if (isPositiveInfinity())
00138     s << infinity_str ;
00139     else
00140     s << _fedTime ;
00141 
00142     return s.str().length() + 1 ;
00143 }
00144 
00145 // ----------------------------------------------------------------------------
00146 void
00147 FedTime::getPrintableString(char *str)
00148 {
00149     std::stringstream s ;
00150 
00151     if (isPositiveInfinity())
00152     s << infinity_str ;
00153     else
00154     s << _fedTime ;
00155 
00156     s >> str ;
00157     str[s.str().length()] = 0 ;
00158 }
00159 
00160 // ----------------------------------------------------------------------------
00161 FedTime &
00162 FedTime::operator+=(const FedTime &time)
00163 {
00164     _fedTime += time._fedTime ;
00165     return *this;
00166 }
00167 
00168 // ----------------------------------------------------------------------------
00169 FedTime &
00170 FedTime::operator-=(const FedTime &time)
00171 {
00172     _fedTime -= time._fedTime ;
00173     return *this;
00174 }
00175 
00176 // ----------------------------------------------------------------------------
00177 bool
00178 FedTime::operator<=(const FedTime &time) const
00179 {
00180     if (const_cast<FedTime &>(time).isPositiveInfinity())
00181     return true;
00182     else if (isPositiveInfinity())
00183     return false;
00184     else
00185     return bool(::fcmp(_fedTime, time._fedTime, _epsilon) <= 0);
00186 }
00187 
00188 // ----------------------------------------------------------------------------
00189 bool
00190 FedTime::operator<(const FedTime &time) const
00191 {
00192     if (isPositiveInfinity())
00193     return false;
00194     else
00195     return bool(time.isPositiveInfinity() || ::fcmp(_fedTime, time._fedTime, _epsilon) < 0);
00196 }
00197 
00198 // ----------------------------------------------------------------------------
00199 bool
00200 FedTime::operator>=(const FedTime &time) const
00201 {
00202     if (isPositiveInfinity())
00203     return true;
00204     else if (time.isPositiveInfinity())
00205     return false;
00206     else
00207     return bool(::fcmp(_fedTime, time._fedTime, _epsilon) >= 0);
00208 }
00209 
00210 // ----------------------------------------------------------------------------
00211 bool
00212 FedTime::operator>(const FedTime &time) const
00213 {
00214     if (time.isPositiveInfinity())
00215     return false;
00216     else
00217     return bool(isPositiveInfinity() || ::fcmp(_fedTime, time._fedTime, _epsilon) > 0);
00218 }
00219 
00220 // ----------------------------------------------------------------------------
00221 bool
00222 FedTime::operator==(const FedTime &time) const
00223 {
00224     if (isPositiveInfinity() && time.isPositiveInfinity())
00225     return true;
00226     else if (isPositiveInfinity() || time.isPositiveInfinity())
00227     return false;
00228     else
00229     return bool(::fcmp(_fedTime, time._fedTime, _epsilon) == 0);
00230 }
00231 
00232 // ----------------------------------------------------------------------------
00233 double
00234 FedTime::getTime() const
00235 {
00236     return _fedTime ;
00237 }
00238 
00239 // ----------------------------------------------------------------------------
00240 bool
00241 FedTime::operator==(const double &time) const
00242 {
00243     return bool(!isPositiveInfinity() && ::fcmp(_fedTime, time, _epsilon) == 0);
00244 }
00245 
00246 // ----------------------------------------------------------------------------
00247 bool
00248 FedTime::operator!=(const FedTime &time) const
00249 {
00250     return bool(::fcmp(_fedTime, time._fedTime, _epsilon) != 0);
00251 }
00252 
00253 // ----------------------------------------------------------------------------
00254 bool
00255 FedTime::operator!=(const double &time) const
00256 {
00257     return bool(isPositiveInfinity() || ::fcmp(_fedTime, time, _epsilon) != 0);
00258 }
00259 
00260 // ----------------------------------------------------------------------------
00261 FedTime &
00262 FedTime::operator=(const FedTime &time)
00263 {
00264     _fedTime = time._fedTime ;
00265     return *this ;
00266 }
00267 
00268 // ----------------------------------------------------------------------------
00269 FedTime &
00270 FedTime::operator=(const double &time)
00271 {
00272     _fedTime = time ;
00273     return *this ;
00274 }
00275 
00276 FedTime &
00277 FedTime::operator*=(const FedTime &time)
00278 {
00279     _fedTime *= time._fedTime ;
00280     return *this ;
00281 }
00282 
00283 FedTime &
00284 FedTime::operator/=(const FedTime &time)
00285 {
00286     _fedTime /= time._fedTime ;
00287     return *this ;
00288 }
00289 
00290 FedTime &
00291 FedTime::operator+=(const double &time)
00292 {
00293     _fedTime += time ;
00294     return *this ;
00295 }
00296 
00297 FedTime &
00298 FedTime::operator-=(const double &time)
00299 {
00300     _fedTime -= time ;
00301     return *this ;
00302 }
00303 
00304 FedTime &
00305 FedTime::operator*=(const double &time)
00306 {
00307     _fedTime *= time ;
00308     return *this ;
00309 }
00310 
00311 FedTime &
00312 FedTime::operator/=(const double &time)
00313 {
00314     _fedTime /= time ;
00315     return *this ;
00316 }
00317 
00318 // ----------------------------------------------------------------------------
00319 FedTime
00320 FedTime::operator+(const FedTime &time)
00321 {
00322     FedTime fedtime = _fedTime + time._fedTime ;
00323     return fedtime ;
00324 }
00325 
00326 FedTime
00327 FedTime::operator+(const double &time)
00328 {
00329     FedTime fedtime = _fedTime + time ;
00330     return fedtime ;
00331 }
00332 
00333 // ----------------------------------------------------------------------------
00334 FedTime
00335 FedTime::operator-(const FedTime &time)
00336 {
00337     FedTime fedtime = _fedTime - time._fedTime ;
00338     return fedtime ;
00339 }
00340 
00341 FedTime
00342 FedTime::operator-(const double &time)
00343 {
00344     FedTime fedtime = _fedTime - time ;
00345     return fedtime ;
00346 }
00347 
00348 // ----------------------------------------------------------------------------
00349 FedTime
00350 FedTime::operator*(const FedTime &time)
00351 {
00352     FedTime fedtime = _fedTime * time._fedTime ;
00353     return fedtime ;
00354 }
00355 
00356 FedTime
00357 FedTime::operator*(const double &time)
00358 {
00359     FedTime fedtime = _fedTime * time ;
00360     return fedtime ;
00361 }
00362 
00363 // ----------------------------------------------------------------------------
00364 FedTime
00365 FedTime::operator/(const FedTime &time)
00366 {
00367     FedTime fedtime = _fedTime / time._fedTime ;
00368     return fedtime ;
00369 }
00370 
00371 FedTime
00372 FedTime::operator/(const double &time)
00373 {
00374     FedTime fedtime = _fedTime / time ;
00375     return fedtime ;
00376 }
00377 
00378 // ----------------------------------------------------------------------------
00379 namespace certi {
00380 std::ostream &
00381 operator<<(std::ostream &s, const FedTime &time)
00382 {
00383     if (time.isPositiveInfinity())
00384     s << infinity_str ;
00385     else
00386     s << time.getTime();
00387     return s ;
00388 }
00389 }
00390 // ============================================================================
00391 
00392 // ----------------------------------------------------------------------------
00393 FedTime
00394 operator+(const double &d, const FedTime &time)
00395 {
00396     FedTime fedtime = d + time.getTime();
00397     return fedtime ;
00398 }
00399 
00400 // ----------------------------------------------------------------------------
00401 FedTime
00402 operator-(const double &d, const FedTime &time)
00403 {
00404     FedTime fedtime = d - time.getTime();
00405     return fedtime ;
00406 }
00407 
00408 // ----------------------------------------------------------------------------
00409 FedTime
00410 operator*(const double &d, const FedTime &time)
00411 {
00412     FedTime fedtime = d * time.getTime();
00413     return fedtime ;
00414 }
00415 
00416 // ----------------------------------------------------------------------------
00417 FedTime
00418 operator/(const double &d, const FedTime &time)
00419 {
00420     FedTime fedtime = d / time.getTime();
00421     return fedtime ;
00422 }
00423 
00424 // $Id: FedTime.cc,v 3.16 2009/04/02 19:58:09 erk Exp $
00425 

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