TimeStamp.h

#ifndef BASE_TIMESTAMP_H
#define BASE_TIMESTAMP_H
 
 
#include <cstdint>
 
 
namespace base {
 
   typedef uint64_t LocalStamp_t;
 
 
   typedef double GlobalTime_t;
 
 
   class LocalStampConverter {
      protected:
         int64_t  fT0;          
         uint64_t fWrapSize;    
         uint64_t fHalfWrapSize; 
         uint64_t fValueMask;   
 
         uint64_t fCurrentWrap; 
         LocalStamp_t fRef;     
         int64_t  fConvRef;     
 
         double fCoef;          
 
      public:
 
         LocalStampConverter() :
            fT0(0),
            fWrapSize(2),
            fHalfWrapSize(1),
            fValueMask(1),
            fCurrentWrap(0),
            fRef(0),
            fConvRef(0),
            fCoef(1.)
         {
         }
 
         ~LocalStampConverter() {}
 
         void SetT0(int64_t t0) { fT0 = t0; }
 
         void SetTimeSystem(unsigned wrapbits, double coef)
         {
            fWrapSize = ((uint64_t) 1) << wrapbits;
            fHalfWrapSize = fWrapSize/2;
            fValueMask = fWrapSize - 1;
            fCoef = coef;
 
            // TODO: should it be done here???
            MoveRef(0);
         }
 
         int64_t distance(LocalStamp_t t1, LocalStamp_t t2) const
         {
            uint64_t diff = (t2 - t1) & fValueMask;
            return diff < fWrapSize/2 ? (int64_t) diff : (int64_t)diff - fWrapSize;
         }
 
         uint64_t abs_distance(LocalStamp_t t1, LocalStamp_t t2)
         {
            uint64_t diff = (t2 - t1) & fValueMask;
            return diff < fWrapSize/2 ? diff : fWrapSize - diff;
         }
 
         double ToSeconds(LocalStamp_t stamp) const
         {
            // simplest way just return stamp*fCoef,
            // but one should account all possible wraps
 
            // first estimate distance to the reference
            // stamp could be left or right
            int64_t dist = distance(fRef, stamp);
 
            // one we found distance, we could calculate full stamp as
            // return (fCurrentWrap + fRef + dist - fT0) * fCoef;
            return (fConvRef + dist) * fCoef;
         }
 
         void MoveRef(LocalStamp_t newref)
         {
            // when new reference smaller than previous
            // one should check if distance small that we could believe it is normal
            if (newref < fRef) {
               int64_t shift = distance(fRef, newref);
               if ((shift>0) && (shift < (int64_t) fWrapSize/2))
                  fCurrentWrap+=fWrapSize;
            }
 
            fRef = newref;
 
            // precalculate value, which will be used for conversion
            fConvRef = int64_t(fCurrentWrap + fRef) - fT0;
         }
   };
 
}
 
#endif