timestamp.hxx

Go to the documentation of this file.

// Written by Curtis Olson, started December 1998.
//
// Copyright (C) 1998  Curtis L. Olson  - http://www.flightgear.org/~curt
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation; either version 2 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
//
// $Id: timestamp_8hxx_source.html,v 1.3 2010/02/23 22:10:17 curt Exp $


#ifndef _TIMESTAMP_HXX
#define _TIMESTAMP_HXX


#ifndef __cplusplus
# error This library requires C++
#endif

#include <iosfwd>
#include <iomanip>
#include <sstream>
#include <simgear/compiler.h>
#include <simgear/math/SGCMath.hxx>

class SGTimeStamp {
public:
    typedef long sec_type;
    typedef int nsec_type;

    SGTimeStamp() :
      _nsec(0),
      _sec(0)
    { }

//     SGTimeStamp(sec_type sec)
//     { setTime(sec, 0); }
//     SGTimeStamp(int sec)
//     { setTime(sec, 0); }
//     SGTimeStamp(const double& sec)
//     { setTime(sec); }

    void stamp();

    void setTime(const double& seconds)
    {
        sec_type wholeSecs = sec_type(floor(seconds));
        nsec_type reminder;
        reminder = nsec_type(floor((seconds - wholeSecs)*(1000*1000*1000)));
        setTime(wholeSecs, reminder);
    }
    void setTime(sec_type sec, nsec_type nsec)
    {
        if (0 <= nsec) {
            _sec = sec + nsec / (1000*1000*1000);
            _nsec = nsec % (1000*1000*1000);
        } else {
            _sec = sec - 1 + nsec / (1000*1000*1000);
            _nsec = (1000*1000*1000) + nsec % (1000*1000*1000);
        }
    }

    
    long get_seconds() const { return _sec; }

    int get_usec() const { return _nsec/1000; }

    const sec_type& getSeconds() const
    { return _sec; }
    const nsec_type& getNanoSeconds() const
    { return _nsec; }

    double toNSecs() const
    { return _nsec + double(_sec)*1000*1000*1000; }

    double toUSecs() const
    { return 1e-3*_nsec + double(_sec)*1000*1000; }

    double toMSecs() const
    { return 1e-6*_nsec + double(_sec)*1000; }

    double toSecs() const
    { return 1e-9*_nsec + _sec; }

    SGTimeStamp& operator+=(const SGTimeStamp& c)
    {
        _sec += c._sec;
        _nsec += c._nsec;
        if ((1000*1000*1000) <= _nsec) {
            _nsec -= (1000*1000*1000);
            _sec += 1;
        }
        return *this;
    }

    SGTimeStamp& operator-=(const SGTimeStamp& c)
    {
        _sec -= c._sec;
        _nsec -= c._nsec;
        if (_nsec < 0) {
            _nsec += (1000*1000*1000);
            _sec -= 1;
        }
        return *this;
    }

    static SGTimeStamp fromSecMSec(sec_type sec, nsec_type msec)
    { return SGTimeStamp(sec, 1000*1000*msec); }
    static SGTimeStamp fromSecUSec(sec_type sec, nsec_type usec)
    { return SGTimeStamp(sec, 1000*usec); }
    static SGTimeStamp fromSecNSec(sec_type sec, nsec_type nsec)
    { return SGTimeStamp(sec, nsec); }

    static SGTimeStamp fromSec(int sec)
    { SGTimeStamp ts; ts.setTime(sec); return ts; }
    static SGTimeStamp fromSec(const double& sec)
    { SGTimeStamp ts; ts.setTime(sec); return ts; }
    static SGTimeStamp fromUSec(nsec_type usec)
    { return SGTimeStamp(0, 1000*usec); }
    static SGTimeStamp fromNSec(nsec_type nsec)
    { return SGTimeStamp(0, nsec); }

    static SGTimeStamp now()
    { SGTimeStamp ts; ts.stamp(); return ts; }

private:
    SGTimeStamp(sec_type sec, nsec_type nsec)
    { setTime(sec, nsec); }

    nsec_type _nsec;
    sec_type _sec;
};

inline bool
operator==(const SGTimeStamp& c1, const SGTimeStamp& c2)
{
  if (c1.getNanoSeconds() != c2.getNanoSeconds())
    return false;
  return c1.getSeconds() == c2.getSeconds();
}

inline bool
operator!=(const SGTimeStamp& c1, const SGTimeStamp& c2)
{ return !operator==(c1, c2); }

inline bool
operator<(const SGTimeStamp& c1, const SGTimeStamp& c2)
{
  if (c1.getSeconds() < c2.getSeconds())
    return true;
  if (c1.getSeconds() > c2.getSeconds())
    return false;
  return c1.getNanoSeconds() < c2.getNanoSeconds();
}

inline bool
operator>(const SGTimeStamp& c1, const SGTimeStamp& c2)
{ return c2 < c1; }

inline bool
operator>=(const SGTimeStamp& c1, const SGTimeStamp& c2)
{ return !(c1 < c2); }

inline bool
operator<=(const SGTimeStamp& c1, const SGTimeStamp& c2)
{ return !(c1 > c2); }

inline SGTimeStamp
operator+(const SGTimeStamp& c1)
{ return c1; }

inline SGTimeStamp
operator-(const SGTimeStamp& c1)
{ return SGTimeStamp::fromSec(0) -= c1; }

inline SGTimeStamp
operator+(const SGTimeStamp& c1, const SGTimeStamp& c2)
{ return SGTimeStamp(c1) += c2; }

inline SGTimeStamp
operator-(const SGTimeStamp& c1, const SGTimeStamp& c2)
{ return SGTimeStamp(c1) -= c2; }

template<typename char_type, typename traits_type> 
inline
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const SGTimeStamp& c)
{
  std::basic_stringstream<char_type, traits_type> stream;

  SGTimeStamp pos = c;
  if (c.getSeconds() < 0) {
    stream << stream.widen('-');
    pos = - c;
  }
  stream << pos.getSeconds() << stream.widen('.');
  stream << std::setw(9) << std::setfill('0') << pos.getNanoSeconds();

  return os << stream.str();
}

#endif // _TIMESTAMP_HXX

---