TimeStamp.h

Go to the documentation of this file.

#ifndef _utl_TimeStamp_h_
#define _utl_TimeStamp_h_

#include <string>
#include <ostream>

#include <utl/AugerUnits.h>


struct tm;

namespace utl {

  class TimeInterval;


  class TimeStamp {

  public:
    TimeStamp() : fGPSSecond(0), fGPSNanoSecond(0) { }

    TimeStamp(const long sec, const double nsec = 0)
    { SetNormalized(sec, nsec); }

    void SetGPSTime(const unsigned long sec, const double nsec = 0)
    { SetNormalized(sec, nsec); }

    unsigned long GetGPSSecond() const { return fGPSSecond; }

    double GetGPSNanoSecond() const { return fGPSNanoSecond; }

    // ---------------------
    // Arithmetic operations
    // ---------------------

    TimeStamp operator+(const TimeInterval& ti) const;

    TimeStamp& operator+=(const TimeInterval& ti);

    TimeInterval operator-(const TimeStamp& ts) const;

    TimeStamp operator-(const TimeInterval& ti) const;

    TimeStamp& operator-=(const TimeInterval& ti);

    // ------------------
    // Boolean operations
    // ------------------

    bool operator==(const TimeStamp& ts) const
    { return (fGPSSecond     == ts.fGPSSecond &&
              fGPSNanoSecond == ts.fGPSNanoSecond); }

    bool operator!=(const TimeStamp& ts) const
    { return !operator==(ts); }

    bool operator>(const TimeStamp& ts) const
    { return (fGPSSecond > ts.fGPSSecond ||
              (fGPSSecond == ts.fGPSSecond &&
               fGPSNanoSecond > ts.fGPSNanoSecond)); }

    bool operator>=(const TimeStamp& ts) const
    { return !operator<(ts); }

    bool operator<(const TimeStamp& ts) const
    { return (fGPSSecond < ts.fGPSSecond ||
              (fGPSSecond == ts.fGPSSecond &&
               fGPSNanoSecond < ts.fGPSNanoSecond)); }

    bool operator<=(const TimeStamp& ts) const
    { return !operator>(ts); }

    explicit operator bool() const { return fGPSSecond || fGPSNanoSecond; }

    static TimeStamp Max() { return TimeStamp(2147483647UL, 999999999.9999999); }

  private:
    // with this we will have a y2k problem in approx. 136 years -
    // or for some operations in 68 years - from 1980 (GPS epoch)
    unsigned long fGPSSecond;
    double fGPSNanoSecond;

    void SetNormalized(long sec, double nsec);

  };


  TimeStamp GetCurrentSystemTime();


  std::ostream& operator<<(std::ostream& os, const TimeStamp& ts);

}


// the following has to be done in this manner in order to keep
// some important operators inline

#include <utl/AugerUnits.h>
#include <utl/TimeInterval.h>

namespace utl {

  inline
  TimeStamp
  TimeStamp::operator+(const TimeInterval& ti)
    const
  {
    // proper normalization is done by the TimeStamp ctor
    return
      TimeStamp(long(fGPSSecond + ti.GetSecond()),
                fGPSNanoSecond + ti.GetNanoSecond());
  }


  inline
  TimeStamp&
  TimeStamp::operator+=(const TimeInterval& ti)
  {
    SetNormalized(fGPSSecond + ti.GetSecond(),
                  fGPSNanoSecond + ti.GetNanoSecond());
    return *this;
  }


  inline
  TimeInterval
  TimeStamp::operator-(const TimeStamp& ts)
    const
  {
    return
      TimeInterval(
        (long(fGPSSecond) - long(ts.fGPSSecond)) * second +
        (fGPSNanoSecond - ts.fGPSNanoSecond) * nanosecond
      );
  }


  inline
  TimeStamp
  TimeStamp::operator-(const TimeInterval& ti)
    const
  {
    // proper normalization is done by the TimeStamp ctor
    return
      TimeStamp(long(fGPSSecond) - long(ti.GetSecond()),
                fGPSNanoSecond - ti.GetNanoSecond());
  }


  inline
  TimeStamp&
  TimeStamp::operator-=(const TimeInterval& ti)
  {
    SetNormalized(long(fGPSSecond) - long(ti.GetSecond()),
                  fGPSNanoSecond - ti.GetNanoSecond());
    return *this;
  }

}


#endif