time.H

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#ifndef ARCHON_UTILITIES_TIME_H
#define ARCHON_UTILITIES_TIME_H

#include <sys/time.h>
#include <errno.h>
#include <math.h>

#include <ostream>

namespace Archon
{
  namespace Utilities
  {
    using namespace std;

    class Condition; // From "thread.H"

    struct Time
    {
      Time()
      {
        ts.tv_sec = 0;
        ts.tv_nsec = 0;
      }

      explicit Time(long seconds, long nanoSeconds = 0)
      {
        ts.tv_sec = seconds;
        ts.tv_nsec = nanoSeconds;
      }

      explicit Time(double seconds)
      {
        double ip;
        ts.tv_nsec = long(modf(seconds, &ip)*1000000000L);
        ts.tv_sec = long(ip);
      }

      static Time now()
      {
        Time t;
        clock_gettime(CLOCK_REALTIME, &t.ts);
        return t;
      }

      static Time resolution()
      {
        Time t;
        clock_getres(CLOCK_REALTIME, &t.ts);
        return t;
      }

      Time &operator+=(const Time &t)
      {
        ts.tv_nsec += t.ts.tv_nsec;
        ts.tv_sec += t.ts.tv_sec;
        addAdjust();
        return *this;
      }

      Time &operator-=(const Time &t)
      {
        ts.tv_nsec -= t.ts.tv_nsec;
        ts.tv_sec -= t.ts.tv_sec;
        subAdjust();
        return *this;
      }

      Time &operator++()
      {
        ++ts.tv_nsec;
        addAdjust();
        return *this;
      }

      Time &operator--()
      {
        --ts.tv_nsec;
        subAdjust();
        return *this;
      }

      Time operator++(int)
      {
        Time t = *this;
        ++ts.tv_nsec;
        addAdjust();
        return t;
      }

      Time operator--(int)
      {
        Time t = *this;
        --ts.tv_nsec;
        subAdjust();
        return t;
      }

      Time operator+(const Time &t) const { Time u(*this); u += t; return u; }
      Time operator-(const Time &t) const { Time u(*this); u -= t; return u; }

      bool operator==(const Time &t) const
      {
        return ts.tv_sec == t.ts.tv_sec && ts.tv_nsec == t.ts.tv_nsec;
      }

      bool operator!=(const Time &t) const
      {
        return ts.tv_sec != t.ts.tv_sec || ts.tv_nsec != t.ts.tv_nsec;
      }

      bool operator<(const Time &t) const
      {
        return ts.tv_sec < t.ts.tv_sec ||
          ts.tv_sec == t.ts.tv_sec && ts.tv_nsec < t.ts.tv_nsec;
      }

      bool operator>(const Time &t) const
      {
        return ts.tv_sec > t.ts.tv_sec ||
          ts.tv_sec == t.ts.tv_sec && ts.tv_nsec > t.ts.tv_nsec;
      }

      bool operator<=(const Time &t) const
      {
        return ts.tv_sec < t.ts.tv_sec ||
          ts.tv_sec == t.ts.tv_sec && ts.tv_nsec <= t.ts.tv_nsec;
      }

      bool operator>=(const Time &t) const
      {
        return ts.tv_sec > t.ts.tv_sec ||
          ts.tv_sec == t.ts.tv_sec && ts.tv_nsec >= t.ts.tv_nsec;
      }

      void set(long seconds, long nanoSeconds = 0)
      {
        ts.tv_sec = seconds;
        ts.tv_nsec = nanoSeconds;
      }

      void get(long &seconds, long &nanoSeconds) const
      {
        seconds = ts.tv_sec;
        nanoSeconds = ts.tv_nsec;
      }

      void get(long double &seconds) const
      {
        seconds = ts.tv_nsec;
        seconds /= 1E9;
        seconds += ts.tv_sec;
      }

      long getSeconds() const { return ts.tv_sec; }
      void setSeconds(long v) { ts.tv_nsec = 0; ts.tv_sec = v; }
      void addSeconds(long v) { ts.tv_sec += v; }

      long getMilliSeconds() const
      {
        return ts.tv_sec * 1000 + ts.tv_nsec / 1000000L;
      }

      void setMilliSeconds(long v)
      {
        ldiv_t d = ldiv(v, 1000);
        ts.tv_sec = d.quot;
        ts.tv_nsec = d.rem * 1000000L;
      }

      void addMilliSeconds(long v)
      {
        Time t;
        t.setMilliSeconds(v);
        this->operator+=(t);
      }

      long getMicroSeconds() const
      {
        return ts.tv_sec * 1000000L + ts.tv_nsec / 1000;
      }

      void setMicroSeconds(long v)
      {
        ldiv_t d = ldiv(v, 1000000L);
        ts.tv_sec = d.quot;
        ts.tv_nsec = d.rem * 1000;
      }

      void addMicroSeconds(long v)
      {
        Time t;
        t.setMicroSeconds(v);
        this->operator+=(t);
      }

      long getNanoSeconds() const
      {
        return ts.tv_sec * 1000000000L + ts.tv_nsec;
      }

      void setNanoSeconds(long v)
      {
        ldiv_t d = ldiv(v, 1000000000L);
        ts.tv_sec = d.quot;
        ts.tv_nsec = d.rem;
      }

      void addNanoSeconds(long v)
      {
        Time t;
        t.setNanoSeconds(v);
        this->operator+=(t);
      }

    private:
      friend class Condition;

      timespec ts;

      void addAdjust()
      {
        if(ts.tv_nsec < 1000000000L) return;
        ts.tv_nsec -= 1000000000L;
        ++ts.tv_sec;
      }

      void subAdjust()
      {
        if(ts.tv_nsec >= 0) return;
        ts.tv_nsec += 1000000000L;
        --ts.tv_sec;
      }
    };

    namespace Text
    {
      string toString(const Time &);
    }
  }
}

namespace std
{
  ostream &operator<<(ostream &, const Archon::Utilities::Time &);
}

#endif // ARCHON_UTILITIES_TIME_H

---