Add typesafe SteadyTimeStamp.

2 files changed, 63 insertions, 25 deletions

diff --git a/fastos/src/vespa/fastos/timestamp.cpp b/fastos/src/vespa/fastos/timestamp.cpp
index e35f0c968de..d5c7f623fde 100644
--- a/fastos/src/vespa/fastos/timestamp.cpp
+++ b/fastos/src/vespa/fastos/timestamp.cpp
@@ -50,26 +50,34 @@ time() {
 
 namespace {
 
-TimeStamp
+SteadyTimeStamp
 steady_now() {
-    return duration_cast<nanoseconds>(steady_clock::now().time_since_epoch()).count();
+    return SteadyTimeStamp(duration_cast<nanoseconds>(steady_clock::now().time_since_epoch()).count());
 }
 
 }
 
-TimeStamp
+SteadyTimeStamp
 ClockSteady::now()
 {
     return steady_now();
 }
 
-StopWatch &
-StopWatch::start() {
-    _startTime = steady_now();
-    _stopTime = _startTime;
-    return *this;
+const SteadyTimeStamp SteadyTimeStamp::ZERO;
+const SteadyTimeStamp SteadyTimeStamp::FUTURE(TimeStamp::FUTURE);
+
+TimeStamp
+SteadyTimeStamp::toUTC() const {
+    TimeStamp nowUtc = ClockSystem::now();
+    SteadyTimeStamp nowSteady = ClockSteady::now();
+    return nowUtc - (nowSteady - *this);
 }
 
+StopWatch::StopWatch()
+    : _startTime(steady_now()),
+      _stopTime(_startTime)
+{ }
+
 StopWatch &
 StopWatch::stop()  {
     _stopTime = steady_now();
diff --git a/fastos/src/vespa/fastos/timestamp.h b/fastos/src/vespa/fastos/timestamp.h
index 73f289cae9b..2eb895c01f9 100644
--- a/fastos/src/vespa/fastos/timestamp.h
+++ b/fastos/src/vespa/fastos/timestamp.h
@@ -36,24 +36,55 @@ public:
     TimeStamp(long long v) : _time(v)     { }
     TimeStamp(unsigned long long v) : _time(v)  { }
     TimeStamp(Seconds v) : _time(v.val())    { }
-    TimeT val()                              const { return _time; }
-    operator TimeT ()                        const { return val(); }
-    TimeStamp & operator += (const TimeStamp & b)  { _time += b._time; return *this; }
-    TimeStamp & operator -= (const TimeStamp & b)  { _time -= b._time; return *this; }
-    TimeT time()                             const { return val()/NANO; }
-    TimeT ms()                               const { return val()/1000000; }
-    TimeT us()                               const { return val()/1000; }
-    TimeT ns()                               const { return val(); }
-    double sec()                             const { return val()/1000000000.0; }
-    std::string toString()                   const { return asString(sec()); }
+    TimeT val()                      const { return _time; }
+    operator TimeT ()                const { return val(); }
+    TimeStamp & operator += (TimeStamp b)  { _time += b._time; return *this; }
+    TimeStamp & operator -= (TimeStamp b)  { _time -= b._time; return *this; }
+    TimeT time()                     const { return val()/NANO; }
+    TimeT ms()                       const { return val()/1000000; }
+    TimeT us()                       const { return val()/1000; }
+    TimeT ns()                       const { return val(); }
+    double sec()                     const { return val()/1000000000.0; }
+    std::string toString()           const { return asString(sec()); }
     static std::string asString(double timeInSeconds);
     static TimeStamp fromSec(double sec) { return Seconds(sec); }
 private:
     TimeT _time;
 };
 
-inline TimeStamp operator +(const TimeStamp & a, const TimeStamp & b) { return TimeStamp(a.val() + b.val()); }
-inline TimeStamp operator -(const TimeStamp & a, const TimeStamp & b) { return TimeStamp(a.val() - b.val()); }
+inline TimeStamp operator +(TimeStamp a, TimeStamp b) { return TimeStamp(a.val() + b.val()); }
+inline TimeStamp operator -(TimeStamp a, TimeStamp b) { return TimeStamp(a.val() - b.val()); }
+
+class SteadyTimeStamp {
+public:
+    static const SteadyTimeStamp ZERO;
+    static const SteadyTimeStamp FUTURE;
+    SteadyTimeStamp() : _timeStamp() { }
+    explicit SteadyTimeStamp(TimeStamp timeStamp) : _timeStamp(timeStamp) { }
+
+    friend TimeStamp operator -(SteadyTimeStamp a, SteadyTimeStamp b) {
+        return a._timeStamp - b._timeStamp;
+    }
+    friend SteadyTimeStamp operator +(SteadyTimeStamp a, TimeStamp b) {
+        return SteadyTimeStamp(a._timeStamp + b);
+    }
+    friend bool operator != (SteadyTimeStamp a, SteadyTimeStamp b) {
+        return a._timeStamp != b._timeStamp;
+    }
+    friend bool operator == (SteadyTimeStamp a, SteadyTimeStamp b) {
+        return a._timeStamp == b._timeStamp;
+    }
+    friend bool operator < (SteadyTimeStamp a, SteadyTimeStamp b) {
+        return a._timeStamp < b._timeStamp;
+    }
+    friend bool operator > (SteadyTimeStamp a, SteadyTimeStamp b) {
+        return a._timeStamp > b._timeStamp;
+    }
+    TimeStamp toUTC() const;
+    std::string toString() const { return _timeStamp.toString(); };
+private:
+    TimeStamp _timeStamp;
+};
 
 class ClockSystem
 {
@@ -64,15 +95,14 @@ public:
 class ClockSteady
 {
 public:
-    static TimeStamp now();
+    static SteadyTimeStamp now();
 };
 
 class StopWatch
 {
 public:
-    StopWatch() : _startTime(), _stopTime() { }
+    StopWatch();
 
-    StopWatch & start();
     StopWatch & stop();
 
     TimeStamp elapsed() const {
@@ -80,8 +110,8 @@ public:
         return (diff > 0) ? diff : TimeStamp(0);
     }
 private:
-    TimeStamp _startTime;
-    TimeStamp _stopTime;
+    SteadyTimeStamp _startTime;
+    SteadyTimeStamp _stopTime;
 };
 
 time_t time();