diff --git a/src/test/gtest_time_stamp.cpp b/src/test/gtest_time_stamp.cpp index 73a69606e77a8dd45b33bf8789a742db06f062a3..a5feaf39b5e6467866ee89235ccd9579ffa6f568 100644 --- a/src/test/gtest_time_stamp.cpp +++ b/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); diff --git a/src/time_stamp.cpp b/src/time_stamp.cpp index 738ff922b19ba77cfefc2bc19117fa294011a2e2..643c1de6c20deb495455719103fb190794b241e5 100644 --- a/src/time_stamp.cpp +++ b/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 diff --git a/src/time_stamp.h b/src/time_stamp.h index d3902e82f2732bfc63c23a3b223a721435bdadb1..fd5593404036e97b03b705c3953ad02fa18df69d 100644 --- a/src/time_stamp.h +++ b/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);