Resolve "Problem::getState/getTimeStamp considering not initialized processors"

Closes #344 (closed)

include/core/common/time_stamp.h

@@ -23,6 +23,7 @@ class TimeStamp
 {
     protected:
         unsigned long int time_stamp_nano_; ///< Time stamp. Expressed in nanoseconds from 1th jan 1970.
+        bool is_valid_; // time stamp has a valid value
 
     public:
         /** \brief Constructor
@@ -60,6 +61,16 @@ class TimeStamp
          */
         ~TimeStamp();
 
+        /** \brief Value of time stamp is valid
+         *
+         */
+        static TimeStamp Invalid ( );
+        bool ok ( ) const;
+        void setOk ( );
+        void setNOk ( );
+
+        static TimeStamp Now();
+
         /** \brief Time stamp to now
          */
         void setToNow();
@@ -174,19 +185,42 @@ class TimeStamp
 
 };
 
+inline wolf::TimeStamp TimeStamp::Invalid ( )
+{
+    return TimeStamp(-1.0);
+}
+
+inline bool TimeStamp::ok ( ) const
+{
+    return is_valid_;
+}
+
+inline void TimeStamp::setOk ( )
+{
+    is_valid_ = true;
+}
+
+inline void TimeStamp::setNOk ( )
+{
+    is_valid_ = false;
+}
+
 inline void TimeStamp::set(const double& ts)
 {
-    time_stamp_nano_ = (ts > 0 ? (unsigned long int)(ts*NANOSECS) : 0);
+    time_stamp_nano_ = (ts >= 0 ? (unsigned long int)(ts*NANOSECS) : 0);
+    is_valid_ = (ts >= 0);
 }
 
 inline void TimeStamp::set(const unsigned long int& sec, const unsigned long int& nanosec)
 {
     time_stamp_nano_ = sec*NANOSECS+nanosec;
+    is_valid_ = true;
 }
 
 inline void TimeStamp::set(const timeval& ts)
 {
     time_stamp_nano_ = (unsigned long int)(ts.tv_sec*NANOSECS) + (unsigned long int)(ts.tv_usec*1000);
+    is_valid_ = (ts.tv_sec >= 0 and ts.tv_usec >= 0);
 }
 
 inline double TimeStamp::get() const
@@ -207,11 +241,13 @@ inline unsigned long int TimeStamp::getNanoSeconds() const
 inline void TimeStamp::operator =(const TimeStamp& ts)
 {
     time_stamp_nano_ = ts.time_stamp_nano_;
+    is_valid_ = ts.is_valid_;
 }
 
 inline void TimeStamp::operator =(const double& ts)
 {
     time_stamp_nano_ = (unsigned long int)(ts*NANOSECS);
+    is_valid_ = (ts >= 0);
 }
 
 inline bool TimeStamp::operator ==(const TimeStamp& ts) const
@@ -254,7 +290,7 @@ inline double TimeStamp::operator -(const TimeStamp& ts) const
     return double((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);
+//static const TimeStamp TimeStampInvalid() {return TimeStamp(-1.0);}
 
 } // namespace wolf