new implementation

src/test/gtest_time_stamp.cpp

@@ -39,7 +39,7 @@ TEST(WolfTestTimeStamp, TimeStampInitScalar)
   std::stringstream ss;
   start.print(ss);
 
-  ASSERT_STREQ("101010.0000000000", ss.str().c_str());
+  ASSERT_STREQ("101010.000000000", ss.str().c_str());
 
 //  PRINTF("All good at WolfTestTimeStamp::TimeStampInitScalar !\n");
 }
@@ -61,11 +61,58 @@ TEST(WolfTestTimeStamp, TimeStampInitScalarSecNano)
   std::stringstream ss;
   start.print(ss);
 
-  ASSERT_STREQ("101010.0002020200", ss.str().c_str());
+  ASSERT_STREQ("101010.000202020", ss.str().c_str());
 
 //  PRINTF("All good at WolfTestTimeStamp::TimeStampInitScalarSecNano !\n");
 }
 
+TEST(WolfTestTimeStamp, TimeStampSetNow)
+{
+  wolf::TimeStamp t1;
+  wolf::TimeStamp t2(t1);
+
+  ASSERT_EQ(t1,t2);
+
+  // If we don't sleep, start == time_stamp sometimes.
+  // And sometimes start <= time_stamp ...
+  std::this_thread::sleep_for(std::chrono::microseconds(1));
+
+  t2.setToNow();
+
+  ASSERT_LT(t1,t2);
+}
+
+TEST(WolfTestTimeStamp, TimeStampSetScalar)
+{
+  wolf::Scalar val(101010.000202020);
+
+  wolf::TimeStamp start;
+  start.set(val);
+
+  ASSERT_EQ(start.get(), val);
+  ASSERT_EQ(start.getSeconds(), 101010);
+  ASSERT_EQ(start.getNanoSeconds(), 202020);
+
+  std::stringstream ss;
+  start.print(ss);
+
+  ASSERT_STREQ("101010.000202020", ss.str().c_str());
+}
+
+TEST(WolfTestTimeStamp, TimeStampSetSecNano)
+{
+  unsigned long int sec(101010);
+  unsigned long int nano(202020);
+
+  wolf::TimeStamp start;
+  start.set(sec,nano);
+
+  // start.get -> 101010.000202020004508
+
+  ASSERT_EQ(start.getSeconds(), sec);
+  ASSERT_EQ(start.getNanoSeconds(), nano);
+}
+
 TEST(WolfTestTimeStamp, TimeStampEquality)
 {
   wolf::TimeStamp start;
@@ -111,14 +158,40 @@ TEST(WolfTestTimeStamp, TimeStampInequality)
 //  PRINTF("All good at WolfTestTimeStamp::TimeStampInequality !\n");
 }
 
+TEST(WolfTestTimeStamp, TimeStampSubstraction)
+{
+  wolf::TimeStamp t1;
+  wolf::TimeStamp t2(t1);
+  wolf::Scalar dt(1e-5);
+
+  t2+=dt;
+
+  ASSERT_LT(t1, t2);
+  ASSERT_EQ(t2-t1, dt);
+  ASSERT_EQ(t1-t2, -dt);
+}
+
+TEST(WolfTestTimeStamp, TimeStampAdding)
+{
+  wolf::TimeStamp t1,t3;
+  wolf::TimeStamp t2(t1);
+  wolf::Scalar dt(1e-5);
+
+  t2 +=dt;
+  t3 = t1+dt;
+
+  ASSERT_EQ(t2, t3);
+}
+
 TEST(WolfTestTimeStamp, TimeStampOperatorOstream)
 {
     wolf::TimeStamp t(5);
     wolf::Scalar dt = 1e-4;
     t+=dt;
+
     std::ostringstream ss1, ss2;
+    t.print(ss1);
 
-    ss1 << t.get();
     ss2 << t;
 
     ASSERT_EQ(ss1.str(), ss2.str());
@@ -126,6 +199,19 @@ TEST(WolfTestTimeStamp, TimeStampOperatorOstream)
 //    PRINTF("All good at WolfTestTimeStamp::TimeStampOperatorOstream !\n");
 }
 
+TEST(WolfTestTimeStamp, TimeStampSecNanoSec)
+{
+    unsigned long int sec = 5;
+    unsigned long int nano = 1e5;
+    wolf::TimeStamp t1(wolf::Scalar(sec)+wolf::Scalar(nano)*1e-9);
+    wolf::TimeStamp t2(sec,nano);
+
+    ASSERT_EQ(t1.getSeconds(),sec);
+    ASSERT_EQ(t2.getSeconds(),sec);
+    ASSERT_EQ(t1.getNanoSeconds(),nano);
+    ASSERT_EQ(t2.getNanoSeconds(),nano);
+}
+
 int main(int argc, char **argv)
 {
   testing::InitGoogleTest(&argc, argv);

src/time_stamp.cpp

@@ -14,26 +14,35 @@ std::ostream& operator<<(std::ostream& os, const TimeStamp& _ts)
     //    std::streamsize nn;
     //    nn = os.precision(TimeStamp::TIME_STAMP_DIGITS_);
 
-    os << _ts.getSeconds() << "." << _ts.getNanoSeconds(); // write obj to stream
+    os << _ts.getSeconds() << "." << std::setfill('0') << std::setw(9) <<_ts.getNanoSeconds(); // write obj to stream
     return os;
 }
 
 
 
 TimeStamp::TimeStamp() :
-        time_stamp_(0)
+        //time_stamp_(0)
+        time_stamp_nano_(0)
 {
     setToNow();
 }
 
-TimeStamp::TimeStamp(const Scalar _ts) :
-        time_stamp_(_ts)
+TimeStamp::TimeStamp(const TimeStamp& _ts) :
+        time_stamp_nano_(_ts.time_stamp_nano_)
 {
     //
 }
 
-TimeStamp::TimeStamp(const unsigned long int _sec, const unsigned long int _nsec) :
-        time_stamp_((Scalar)_sec + (Scalar)_nsec/(Scalar)1e9)
+TimeStamp::TimeStamp(const Scalar& _ts) :
+        //time_stamp_(_ts)
+        time_stamp_nano_((unsigned long int)(_ts*1e9))
+{
+    //
+}
+
+TimeStamp::TimeStamp(const unsigned long int& _sec, const unsigned long int& _nsec) :
+        //time_stamp_((Scalar)_sec + (Scalar)_nsec/(Scalar)1e9)
+        time_stamp_nano_(_sec*NANOSECS+_nsec)
 {
     //
 }
@@ -47,39 +56,41 @@ void TimeStamp::setToNow()
 {
     timeval ts;
     gettimeofday(&ts, NULL);
-    time_stamp_ = (Scalar)((ts.tv_sec)) + (Scalar)((ts.tv_usec)) / 1e6;
+    set(ts);
 }
 
-unsigned long int TimeStamp::getSeconds() const
+TimeStamp TimeStamp::operator +(const Scalar& dt) const
 {
-    unsigned long int ts;
-    ts = (unsigned long int)(((floor(time_stamp_))));
+    TimeStamp ts(*this);
+    ts += dt;
     return ts;
 }
 
-unsigned long int TimeStamp::getNanoSeconds() const
+TimeStamp TimeStamp::operator -(const Scalar& dt) const
 {
-    Scalar ts;
-    ts = (Scalar)(((floor(time_stamp_))));
-    return (unsigned long int)(((time_stamp_ - ts) * 1e9));
+    TimeStamp ts(*this);
+    ts -= dt;
+    return ts;
 }
 
 void TimeStamp::print(std::ostream & ost) const
 {
-    std::streamsize nn;
-    std::ios_base::fmtflags fmtfl;
-
-    //get/set ostream flags and precision digits
-    fmtfl = ost.flags(std::ios::left);
-    ost.setf(std::ios::fixed, std::ios::floatfield);
-    nn = ost.precision(TIME_STAMP_DIGITS_);
-
-    //send to ostream
-    ost << this->time_stamp_;
+    //std::streamsize nn;
+    //std::ios_base::fmtflags fmtfl;
+    //
+    ////get/set ostream flags and precision digits
+    //fmtfl = ost.flags(std::ios::left);
+    //ost.setf(std::ios::fixed, std::ios::floatfield);
+    //nn = ost.precision(TIME_STAMP_DIGITS_);
+    //
+    ////send to ostream
+    //ost << this->time_stamp_;
+    //
+    ////restore flags and precision
+    //ost.flags(fmtfl);
+    //ost.precision(nn);
 
-    //restore flags and precision
-    ost.flags(fmtfl);
-    ost.precision(nn);
+    ost << this->getSeconds() << "." << std::setfill('0') << std::setw(9) << this->getNanoSeconds();
 }
 
 } // namespace wolf

src/time_stamp.h

@@ -8,7 +8,9 @@
 //C, std
 #include <sys/time.h>
 #include <iostream>
+#include <iomanip>
 
+static const unsigned int NANOSECS = 1000000000;
 
 namespace wolf {
 
@@ -19,9 +21,10 @@ namespace wolf {
  */
 class TimeStamp
 {
-    private:
-        Scalar time_stamp_; ///< Time stamp. Expressed in seconds from 1th jan 1970.
-        static const unsigned int TIME_STAMP_DIGITS_ = 10; ///< Number of digits to print time stamp values        
+    protected:
+        unsigned long int time_stamp_nano_; ///< Time stamp. Expressed in nanoseconds from 1th jan 1970.
+        //Scalar time_stamp_; ///< Time stamp. Expressed in seconds from 1th jan 1970.
+        //static const unsigned int TIME_STAMP_DIGITS_ = 10; ///< Number of digits to print time stamp values
 
     public:
         /** \brief Constructor
@@ -31,19 +34,26 @@ class TimeStamp
          */
         TimeStamp();
 
+        /** \brief Copy constructor
+         *
+         * Copy constructor
+         *
+         */
+        TimeStamp(const TimeStamp& _ts);
+
         /** \brief Constructor with argument
          *
          * Constructor with arguments
          *
          */
-        TimeStamp(const Scalar _ts);
+        TimeStamp(const Scalar& _ts);
 
         /** \brief Constructor from sec and nsec
          *
          * Constructor from sec and nsec
          *
          */
-        TimeStamp(const unsigned long int _sec, const unsigned long int _nsec);
+        TimeStamp(const unsigned long int& _sec, const unsigned long int& _nsec);
 
         /** \brief Destructor
          *
@@ -67,14 +77,14 @@ class TimeStamp
          * Sets time stamp to a given value passed as a two-integer (seconds and nanoseconds)
          *
          */
-        void set(const unsigned long int sec, const unsigned long int nanosec);
+        void set(const unsigned long int& sec, const unsigned long int& nanosec);
 
         /** \brief Set time stamp
          *
          * Sets time stamp to a given value passed as a scalar_t (seconds)
          *
          */
-        void set(const Scalar ts);
+        void set(const Scalar& ts);
 
         /** \brief Get time stamp
          *
@@ -129,13 +139,6 @@ class TimeStamp
         bool operator <=(const TimeStamp& ts) const;
         bool operator >=(const TimeStamp& ts) const;
 
-        /** \brief difference operator
-         * 
-         * difference operator that returns a scalar_t (seconds)
-         * 
-         */
-        Scalar operator -(const TimeStamp& ts) const;
-
         /** \brief Add-assign operator given a scalar_t (seconds)
          */
         void operator +=(const Scalar& dt);
@@ -144,6 +147,24 @@ class TimeStamp
          */
         TimeStamp operator +(const Scalar& dt) const;
 
+        /** \brief Substraction-assign operator given a scalar_t (seconds)
+         */
+        void operator -=(const Scalar& dt);
+
+        /** \brief difference operator
+         * 
+         * difference operator that returns a scalar_t (seconds)
+         * 
+         */
+        TimeStamp operator -(const Scalar& ts) const;
+
+        /** \brief difference operator
+         *
+         * difference operator that returns a Timestamp (seconds)
+         *
+         */
+        Scalar operator -(const TimeStamp& ts) const;
+
         /** \brief Prints time stamp to a given ostream
          *
          * Prints time stamp to a given ostream
@@ -155,79 +176,110 @@ class TimeStamp
 
 };
 
-inline void TimeStamp::set(const Scalar ts)
+inline void TimeStamp::set(const Scalar& ts)
 {
-    time_stamp_ = ts;
+    //time_stamp_ = ts;
+    time_stamp_nano_ = (unsigned long int)(ts*NANOSECS);
 }
 
-inline void TimeStamp::set(const unsigned long int sec, const unsigned long int nanosec)
+inline void TimeStamp::set(const unsigned long int& sec, const unsigned long int& nanosec)
 {
-    time_stamp_ = (Scalar)(sec) + (Scalar)(nanosec) / (Scalar)(1e9);
+    //time_stamp_ = (Scalar)(sec) + (Scalar)(nanosec) / (Scalar)(1e9);
+    time_stamp_nano_ = sec*NANOSECS+nanosec;
 }
 
 inline void TimeStamp::set(const timeval& ts)
 {
-    time_stamp_ = (Scalar)(ts.tv_sec) + (Scalar)(ts.tv_usec) / 1e6;
+    //time_stamp_ = (Scalar)(ts.tv_sec) + (Scalar)(ts.tv_usec) / 1e6;
+    time_stamp_nano_ = (unsigned long int)(ts.tv_sec*NANOSECS) + (unsigned long int)(ts.tv_usec*1000);
 }
 
 inline Scalar TimeStamp::get() const
 {
-    return time_stamp_;
+    //return time_stamp_;
+    return ((Scalar)( time_stamp_nano_))*1e-9;
+}
+
+inline unsigned long int TimeStamp::getSeconds() const
+{
+    //unsigned long int ts;
+    //ts = (unsigned long int)(((floor(time_stamp_))));
+    //return ts;
+    return time_stamp_nano_ / NANOSECS;
+}
+
+inline unsigned long int TimeStamp::getNanoSeconds() const
+{
+    //Scalar ts;
+    //ts = (Scalar)((floor(time_stamp_)));
+    //return (unsigned long int)(((time_stamp_ - ts) * 1e9));
+    return time_stamp_nano_ % NANOSECS;
 }
 
 inline void TimeStamp::operator =(const TimeStamp& ts)
 {
-    time_stamp_ = ts.get();
+    //time_stamp_ = ts.get();
+    time_stamp_nano_ = ts.time_stamp_nano_;
 }
 
 inline void TimeStamp::operator =(const Scalar& ts)
 {
-    time_stamp_ = ts;
+    //time_stamp_ = ts;
+    time_stamp_nano_ = (unsigned long int)(ts*NANOSECS);
 }
 
 inline bool TimeStamp::operator ==(const TimeStamp& ts) const
 {
-    return (time_stamp_ == ts.get());
+    //return (time_stamp_ == ts.get());
+    return (time_stamp_nano_ == ts.time_stamp_nano_);
 }
 
 inline bool TimeStamp::operator !=(const TimeStamp& ts) const
 {
-    return (time_stamp_ != ts.get());
+    //return (time_stamp_ != ts.get());
+    return (time_stamp_nano_ != ts.time_stamp_nano_);
 }
 
 inline bool TimeStamp::operator <(const TimeStamp& ts) const
 {
-    return (time_stamp_ < ts.get());
+    //return (time_stamp_ < ts.get());
+    return (time_stamp_nano_ < ts.time_stamp_nano_);
 }
 
 inline bool TimeStamp::operator >(const TimeStamp& ts) const
 {
-    return (time_stamp_ > ts.get());
+    //return (time_stamp_ > ts.get());
+    return (time_stamp_nano_ > ts.time_stamp_nano_);
 }
 
 inline bool TimeStamp::operator <=(const TimeStamp& ts) const
 {
-    return (time_stamp_ <= ts.get());
+    //return (time_stamp_ <= ts.get());
+    return (time_stamp_nano_ <= ts.time_stamp_nano_);
 }
 
 inline bool TimeStamp::operator >=(const TimeStamp& ts) const
 {
-    return (time_stamp_ >= ts.get());
+    //return (time_stamp_ >= ts.get());
+    return (time_stamp_nano_ >= ts.time_stamp_nano_);
 }
 
-inline Scalar TimeStamp::operator -(const TimeStamp& ts) const
+inline void TimeStamp::operator +=(const Scalar& dt)
 {
-    return (time_stamp_ - ts.get());
+    //time_stamp_ += dt;
+    time_stamp_nano_ += (unsigned long int)(dt*NANOSECS);
 }
 
-inline void TimeStamp::operator +=(const Scalar& dt)
+inline void TimeStamp::operator -=(const Scalar& dt)
 {
-    time_stamp_ += dt;
+    //time_stamp_ -= dt;
+    time_stamp_nano_ -= (unsigned long int)(dt*NANOSECS);
 }
 
-inline TimeStamp TimeStamp::operator +(const Scalar& dt) const
+inline Scalar TimeStamp::operator -(const TimeStamp& ts) const
 {
-    return TimeStamp(time_stamp_ + dt);
+    //return (time_stamp_ - ts.get());
+    return Scalar((long int)(time_stamp_nano_ - ts.time_stamp_nano_))*1e-9; // long int cast fix overflow in case of negative substraction result
 }
 
 static const TimeStamp InvalidStamp(-1,-1);