Timestamp.h

Go to the documentation of this file.

#ifndef DataFormats_Provenance_Timestamp_h
#define DataFormats_Provenance_Timestamp_h
// -*- C++ -*-
//
// Package:     DataFormats/Provenance
// Class:      Timestamp
//
//
// Author:      Chris Jones
// Created:     Thu Mar 24 16:23:05 EST 2005
//

// system include files
#include<limits>

// user include files

// forward declarations
namespace edm {
   typedef unsigned long long TimeValue_t;

class Timestamp {

   static const TimeValue_t kLowMask=0xFFFFFFFF;

   public:
      explicit Timestamp(TimeValue_t iValue): 
      timeLow_(static_cast<unsigned int>(kLowMask & iValue)),
      timeHigh_(static_cast<unsigned int>(iValue >> 32)){}


      Timestamp() : timeLow_(invalidTimestamp().timeLow_),
                    timeHigh_(invalidTimestamp().timeHigh_) {}


      unsigned int
      unixTime() const {
        return timeHigh_;
      }

      unsigned int
      microsecondOffset() const {
        return timeLow_;
      }

      TimeValue_t value() const {
        TimeValue_t returnValue = timeHigh_;
        returnValue = returnValue << 32;
        returnValue += timeLow_;
        return returnValue;
      }




      // ---------- const member functions ---------------------
      bool operator==(Timestamp const& iRHS) const {
         return timeHigh_ == iRHS.timeHigh_ &&
         timeLow_ == iRHS.timeLow_;
      }
      bool operator!=(Timestamp const& iRHS) const {
         return !(*this == iRHS);
      }

      bool operator<(Timestamp const& iRHS) const {
         if(timeHigh_ == iRHS.timeHigh_) {
            return timeLow_ < iRHS.timeLow_;
         }
         return timeHigh_ < iRHS.timeHigh_;
      }
      bool operator<=(Timestamp const& iRHS) const {
         if(timeHigh_ == iRHS.timeHigh_) {
            return timeLow_ <= iRHS.timeLow_;
         }
         return timeHigh_ <= iRHS.timeHigh_;
      }
      bool operator>(Timestamp const& iRHS) const {
         if(timeHigh_ == iRHS.timeHigh_) {
            return timeLow_ > iRHS.timeLow_;
         }
         return timeHigh_ > iRHS.timeHigh_;
      }
      bool operator>=(Timestamp const& iRHS) const {
         if(timeHigh_ == iRHS.timeHigh_) {
            return timeLow_ >= iRHS.timeLow_;
         }
         return timeHigh_ >= iRHS.timeHigh_;
      }

      // ---------- static member functions --------------------
      static Timestamp invalidTimestamp() { return Timestamp(0);}
      static Timestamp endOfTime() { return Timestamp(std::numeric_limits<TimeValue_t>::max()); }
      static Timestamp beginOfTime() {return Timestamp(1);}

      // ---------- member functions ---------------------------

   private:
      //Timestamp(Timestamp const&); // allow default

      //Timestamp const& operator=(Timestamp const&); // allow default

      // ---------- member data --------------------------------
      // ROOT does not support ULL
      //TimeValue_t time_;
      unsigned int timeLow_;
      unsigned int timeHigh_;
};

}
#endif