Skip to content
Snippets Groups Projects
Commit 7b9ca12a authored by Joan Vallvé Navarro's avatar Joan Vallvé Navarro
Browse files

new implementation

parent 5cfc52c4
No related branches found
No related tags found
1 merge request!209Time stamp
This commit is part of merge request !209. Comments created here will be created in the context of that merge request.
Hide whitespace changes
Inline Side-by-side
src/test/gtest_time_stamp.cpp
+ 89
− 3
View file @ 7b9ca12a
......@@ -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
+ 38
− 27
View file @ 7b9ca12a
......@@ -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
+ 86
− 34
View file @ 7b9ca12a
......@@ -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);
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment